/// <summary> /// Starts a new heartbeat service on the specified device and connects to it. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// heartbeat_client_t upon successful return. Must be freed using /// heartbeat_client_free() after use. /// </param> /// <param name="label"> /// The label to use for communication. Usually the program name. /// Pass NULL to disable sending the label in requests to lockdownd. /// </param> /// <returns> /// HEARTBEAT_E_SUCCESS on success, or an HEARTBEAT_E_* error /// code otherwise. /// </returns> public virtual HeartBeatError heartbeat_client_start_service(iDeviceHandle device, out HeartBeatClientHandle client, string label) { HeartBeatError returnValue; returnValue = HeartBeatNativeMethods.heartbeat_client_start_service(device, out client, label); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Connects to the house_arrest service on the specified device. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="service"> /// The service descriptor returned by lockdownd_start_service. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// housearrest_client_t upon successful return. /// </param> /// <returns> /// HOUSE_ARREST_E_SUCCESS on success, HOUSE_ARREST_E_INVALID_ARG when /// client is NULL, or an HOUSE_ARREST_E_* error code otherwise. /// </returns> public virtual HouseArrestError house_arrest_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out HouseArrestClientHandle client) { HouseArrestError returnValue; returnValue = HouseArrestNativeMethods.house_arrest_client_new(device, service, out client); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Connects to the springboardservices service on the specified device. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="service"> /// The service descriptor returned by lockdownd_start_service. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// sbservices_client_t upon successful return. /// </param> /// <returns> /// SBSERVICES_E_SUCCESS on success, SBSERVICES_E_INVALID_ARG when /// client is NULL, or an SBSERVICES_E_* error code otherwise. /// </returns> public virtual SpringBoardServicesError sbservices_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out SpringBoardServicesClientHandle client) { SpringBoardServicesError returnValue; returnValue = SpringBoardServicesNativeMethods.sbservices_client_new(device, service, out client); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Connects to the installation_proxy service on the specified device. /// </summary> /// <param name="device"> /// The device to connect to /// </param> /// <param name="service"> /// The service descriptor returned by lockdownd_start_service. /// </param> /// <param name="client"> /// Pointer that will be set to a newly allocated /// instproxy_client_t upon successful return. /// </param> /// <returns> /// INSTPROXY_E_SUCCESS on success, or an INSTPROXY_E_* error value /// when an error occured. /// </returns> public virtual InstallationProxyError instproxy_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out InstallationProxyClientHandle client) { InstallationProxyError returnValue; returnValue = InstallationProxyNativeMethods.instproxy_client_new(device, service, out client); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Connects to the mobilebackup service on the specified device. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="service"> /// The service descriptor returned by lockdownd_start_service. /// </param> /// <param name="client"> /// Pointer that will be set to a newly allocated /// mobilebackup_client_t upon successful return. /// </param> /// <returns> /// MOBILEBACKUP_E_SUCCESS on success, MOBILEBACKUP_E_INVALID ARG if one /// or more parameters are invalid, or DEVICE_LINK_SERVICE_E_BAD_VERSION if /// the mobilebackup version on the device is newer. /// </returns> public virtual MobileBackupError mobilebackup_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out MobileBackupClientHandle client) { MobileBackupError returnValue; returnValue = MobileBackupNativeMethods.mobilebackup_client_new(device, service, out client); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Starts a new misagent service on the specified device and connects to it. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// misagent_client_t upon successful return. Must be freed using /// misagent_client_free() after use. /// </param> /// <param name="label"> /// The label to use for communication. Usually the program name. /// Pass NULL to disable sending the label in requests to lockdownd. /// </param> /// <returns> /// MISAGENT_E_SUCCESS on success, or an MISAGENT_E_* error /// code otherwise. /// </returns> public virtual MisagentError misagent_client_start_service(iDeviceHandle device, out MisagentClientHandle client, string label) { MisagentError returnValue; returnValue = MisagentNativeMethods.misagent_client_start_service(device, out client, label); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Starts a new syslog_relay service on the specified device and connects to it. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// syslog_relay_client_t upon successful return. Must be freed using /// syslog_relay_client_free() after use. /// </param> /// <param name="label"> /// The label to use for communication. Usually the program name. /// Pass NULL to disable sending the label in requests to lockdownd. /// </param> /// <returns> /// SYSLOG_RELAY_E_SUCCESS on success, or an SYSLOG_RELAY_E_* error /// code otherwise. /// </returns> public virtual SyslogRelayError syslog_relay_client_start_service(iDeviceHandle device, out SyslogRelayClientHandle client, string label) { SyslogRelayError returnValue; returnValue = SyslogRelayNativeMethods.syslog_relay_client_start_service(device, out client, label); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Connects to the file_relay service on the specified device. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="service"> /// The service descriptor returned by lockdownd_start_service. /// </param> /// <param name="client"> /// Reference that will point to a newly allocated /// file_relay_client_t upon successful return. /// </param> /// <returns> /// FILE_RELAY_E_SUCCESS on success, /// FILE_RELAY_E_INVALID_ARG when one of the parameters is invalid, /// or FILE_RELAY_E_MUX_ERROR when the connection failed. /// </returns> public virtual FileRelayError file_relay_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out FileRelayClientHandle client) { FileRelayError returnValue; returnValue = FileRelayNativeMethods.file_relay_client_new(device, service, out client); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Starts a new file_relay service on the specified device and connects to it. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// file_relay_client_t upon successful return. Must be freed using /// file_relay_client_free() after use. /// </param> /// <param name="label"> /// The label to use for communication. Usually the program name. /// Pass NULL to disable sending the label in requests to lockdownd. /// </param> /// <returns> /// FILE_RELAY_E_SUCCESS on success, or an FILE_RELAY_E_* error /// code otherwise. /// </returns> public virtual FileRelayError file_relay_client_start_service(iDeviceHandle device, out FileRelayClientHandle client, string label) { FileRelayError returnValue; returnValue = FileRelayNativeMethods.file_relay_client_start_service(device, out client, label); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Connects to the notification_proxy on the specified device. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="service"> /// The service descriptor returned by lockdownd_start_service. /// </param> /// <param name="client"> /// Pointer that will be set to a newly allocated np_client_t /// upon successful return. /// </param> /// <returns> /// NP_E_SUCCESS on success, NP_E_INVALID_ARG when device is NULL, /// or NP_E_CONN_FAILED when the connection to the device could not be /// established. /// </returns> public virtual NotificationProxyError np_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out NotificationProxyClientHandle client) { NotificationProxyError returnValue; returnValue = NotificationProxyNativeMethods.np_client_new(device, service, out client); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Starts a new notification proxy service on the specified device and connects to it. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// np_client_t upon successful return. Must be freed using /// np_client_free() after use. /// </param> /// <param name="label"> /// The label to use for communication. Usually the program name. /// Pass NULL to disable sending the label in requests to lockdownd. /// </param> /// <returns> /// NP_E_SUCCESS on success, or an NP_E_* error /// code otherwise. /// </returns> public virtual NotificationProxyError np_client_start_service(iDeviceHandle device, out NotificationProxyClientHandle client, string label) { NotificationProxyError returnValue; returnValue = NotificationProxyNativeMethods.np_client_start_service(device, out client, label); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Connects to the mobile_image_mounter service on the specified device. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="service"> /// The service descriptor returned by lockdownd_start_service. /// </param> /// <param name="client"> /// Pointer that will be set to a newly allocated /// mobile_image_mounter_client_t upon successful return. /// </param> /// <returns> /// MOBILE_IMAGE_MOUNTER_E_SUCCESS on success, /// MOBILE_IMAGE_MOUNTER_E_INVALID_ARG if device is NULL, /// or MOBILE_IMAGE_MOUNTER_E_CONN_FAILED if the connection to the /// device could not be established. /// </returns> public virtual MobileImageMounterError mobile_image_mounter_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out MobileImageMounterClientHandle client) { MobileImageMounterError returnValue; returnValue = MobileImageMounterNativeMethods.mobile_image_mounter_new(device, service, out client); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Starts a new mobile_image_mounter service on the specified device and connects to it. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// mobile_image_mounter_t upon successful return. Must be freed using /// mobile_image_mounter_free() after use. /// </param> /// <param name="label"> /// The label to use for communication. Usually the program name. /// Pass NULL to disable sending the label in requests to lockdownd. /// </param> /// <returns> /// MOBILE_IMAGE_MOUNTER_E_SUCCESS on success, or an MOBILE_IMAGE_MOUNTER_E_* error /// code otherwise. /// </returns> public virtual MobileImageMounterError mobile_image_mounter_start_service(iDeviceHandle device, out MobileImageMounterClientHandle client, string label) { MobileImageMounterError returnValue; returnValue = MobileImageMounterNativeMethods.mobile_image_mounter_start_service(device, out client, label); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Starts a new sbservices service on the specified device and connects to it. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// sbservices_client_t upon successful return. Must be freed using /// sbservices_client_free() after use. /// </param> /// <param name="label"> /// The label to use for communication. Usually the program name. /// Pass NULL to disable sending the label in requests to lockdownd. /// </param> /// <returns> /// SBSERVICES_E_SUCCESS on success, or an SBSERVICES_E_* error /// code otherwise. /// </returns> public virtual SpringBoardServicesError sbservices_client_start_service(iDeviceHandle device, out SpringBoardServicesClientHandle client, string label) { SpringBoardServicesError returnValue; returnValue = SpringBoardServicesNativeMethods.sbservices_client_start_service(device, out client, label); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Creates a new property list service for the specified port. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="service"> /// The service descriptor returned by lockdownd_start_service. /// </param> /// <param name="client"> /// Pointer that will be set to a newly allocated /// property_list_service_client_t upon successful return. /// </param> /// <returns> /// PROPERTY_LIST_SERVICE_E_SUCCESS on success, /// PROPERTY_LIST_SERVICE_E_INVALID_ARG when one of the arguments is invalid, /// or PROPERTY_LIST_SERVICE_E_MUX_ERROR when connecting to the device failed. /// </returns> public virtual PropertyListServiceError property_list_service_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out PropertyListServiceClientHandle client) { PropertyListServiceError returnValue; returnValue = PropertyListServiceNativeMethods.property_list_service_client_new(device, service, out client); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Connects to the debugserver service on the specified device. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="service"> /// The service descriptor returned by lockdownd_start_service. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// debugserver_client_t upon successful return. Must be freed using /// debugserver_client_free() after use. /// </param> /// <returns> /// DEBUGSERVER_E_SUCCESS on success, DEBUGSERVER_E_INVALID_ARG when /// client is NULL, or an DEBUGSERVER_E_* error code otherwise. /// </returns> public virtual DebugServerError debugserver_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out DebugServerClientHandle client) { DebugServerError returnValue; returnValue = DebugServerNativeMethods.debugserver_client_new(device, service, out client); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Connects to the misagent service on the specified device. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="service"> /// The service descriptor returned by lockdownd_start_service. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// misagent_client_t upon successful return. /// </param> /// <returns> /// MISAGENT_E_SUCCESS on success, MISAGENT_E_INVALID_ARG when /// client is NULL, or an MISAGENT_E_* error code otherwise. /// </returns> public virtual MisagentError misagent_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out MisagentClientHandle client) { MisagentError returnValue; returnValue = MisagentNativeMethods.misagent_client_new(device, service, out client); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Starts a new debugserver service on the specified device and connects to it. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// debugserver_client_t upon successful return. Must be freed using /// debugserver_client_free() after use. /// </param> /// <param name="label"> /// The label to use for communication. Usually the program name. /// Pass NULL to disable sending the label in requests to lockdownd. /// </param> /// <returns> /// DEBUGSERVER_E_SUCCESS on success, or an DEBUGSERVER_E_* error /// code otherwise. /// </returns> public virtual DebugServerError debugserver_client_start_service(iDeviceHandle device, out DebugServerClientHandle client, string label) { DebugServerError returnValue; returnValue = DebugServerNativeMethods.debugserver_client_start_service(device, out client, label); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Connects to the syslog_relay service on the specified device. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="service"> /// The service descriptor returned by lockdownd_start_service. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// syslog_relay_client_t upon successful return. Must be freed using /// syslog_relay_client_free() after use. /// </param> /// <returns> /// SYSLOG_RELAY_E_SUCCESS on success, SYSLOG_RELAY_E_INVALID_ARG when /// client is NULL, or an SYSLOG_RELAY_E_* error code otherwise. /// </returns> public virtual SyslogRelayError syslog_relay_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out SyslogRelayClientHandle client) { SyslogRelayError returnValue; returnValue = SyslogRelayNativeMethods.syslog_relay_client_new(device, service, out client); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Connects to the diagnostics_relay service on the specified device. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="service"> /// The service descriptor returned by lockdownd_start_service. /// </param> /// <param name="client"> /// Reference that will point to a newly allocated /// diagnostics_relay_client_t upon successful return. /// </param> /// <returns> /// DIAGNOSTICS_RELAY_E_SUCCESS on success, /// DIAGNOSTICS_RELAY_E_INVALID_ARG when one of the parameters is invalid, /// or DIAGNOSTICS_RELAY_E_MUX_ERROR when the connection failed. /// </returns> public virtual DiagnosticsRelayError diagnostics_relay_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out DiagnosticsRelayClientHandle client) { DiagnosticsRelayError returnValue; returnValue = DiagnosticsRelayNativeMethods.diagnostics_relay_client_new(device, service, out client); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Creates a new service for the specified service descriptor. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="service"> /// The service descriptor returned by lockdownd_start_service. /// </param> /// <param name="client"> /// Pointer that will be set to a newly allocated /// service_client_t upon successful return. /// </param> /// <returns> /// SERVICE_E_SUCCESS on success, /// SERVICE_E_INVALID_ARG when one of the arguments is invalid, /// or SERVICE_E_MUX_ERROR when connecting to the device failed. /// </returns> public virtual ServiceError service_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out ServiceClientHandle client) { ServiceError returnValue; returnValue = ServiceNativeMethods.service_client_new(device, service, out client); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Starts a new diagnostics_relay service on the specified device and connects to it. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// diagnostics_relay_client_t upon successful return. Must be freed using /// diagnostics_relay_client_free() after use. /// </param> /// <param name="label"> /// The label to use for communication. Usually the program name. /// Pass NULL to disable sending the label in requests to lockdownd. /// </param> /// <returns> /// DIAGNOSTICS_RELAY_E_SUCCESS on success, or an DIAGNOSTICS_RELAY_E_* error /// code otherwise. /// </returns> public virtual DiagnosticsRelayError diagnostics_relay_client_start_service(iDeviceHandle device, out DiagnosticsRelayClientHandle client, string label) { DiagnosticsRelayError returnValue; returnValue = DiagnosticsRelayNativeMethods.diagnostics_relay_client_start_service(device, out client, label); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Starts a new installation_proxy service on the specified device and connects to it. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// instproxy_client_t upon successful return. Must be freed using /// instproxy_client_free() after use. /// </param> /// <param name="label"> /// The label to use for communication. Usually the program name. /// Pass NULL to disable sending the label in requests to lockdownd. /// </param> /// <returns> /// INSTPROXY_E_SUCCESS on success, or an INSTPROXY_E_* error /// code otherwise. /// </returns> public virtual InstallationProxyError instproxy_client_start_service(iDeviceHandle device, out InstallationProxyClientHandle client, string label) { InstallationProxyError returnValue; returnValue = InstallationProxyNativeMethods.instproxy_client_start_service(device, out client, label); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Creates a new restored client for the device. /// </summary> /// <param name="device"> /// The device to create a restored client for /// </param> /// <param name="client"> /// The pointer to the location of the new restored_client /// </param> /// <param name="label"> /// The label to use for communication. Usually the program name. /// </param> /// <returns> /// RESTORE_E_SUCCESS on success, RESTORE_E_INVALID_ARG when client is NULL /// </returns> public virtual RestoreError restored_client_new(iDeviceHandle device, out RestoreClientHandle client, string label) { RestoreError returnValue; returnValue = RestoreNativeMethods.restored_client_new(device, out client, label); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Starts a new mobilebackup service on the specified device and connects to it. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// mobilebackup_client_t upon successful return. Must be freed using /// mobilebackup_client_free() after use. /// </param> /// <param name="label"> /// The label to use for communication. Usually the program name. /// Pass NULL to disable sending the label in requests to lockdownd. /// </param> /// <returns> /// MOBILEBACKUP_E_SUCCESS on success, or an MOBILEBACKUP_E_* error /// code otherwise. /// </returns> public virtual MobileBackupError mobilebackup_client_start_service(iDeviceHandle device, out MobileBackupClientHandle client, string label) { MobileBackupError returnValue; returnValue = MobileBackupNativeMethods.mobilebackup_client_start_service(device, out client, label); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Connects to the heartbeat service on the specified device. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="service"> /// The service descriptor returned by lockdownd_start_service. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// heartbeat_client_t upon successful return. Must be freed using /// heartbeat_client_free() after use. /// </param> /// <returns> /// HEARTBEAT_E_SUCCESS on success, HEARTBEAT_E_INVALID_ARG when /// client is NULL, or an HEARTBEAT_E_* error code otherwise. /// </returns> public virtual HeartBeatError heartbeat_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out HeartBeatClientHandle client) { HeartBeatError returnValue; returnValue = HeartBeatNativeMethods.heartbeat_client_new(device, service, out client); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Starts a new house_arrest service on the specified device and connects to it. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated /// house_arrest_client_t upon successful return. Must be freed using /// house_arrest_client_free() after use. /// </param> /// <param name="label"> /// The label to use for communication. Usually the program name. /// Pass NULL to disable sending the label in requests to lockdownd. /// </param> /// <returns> /// HOUSE_ARREST_E_SUCCESS on success, or an HOUSE_ARREST_E_* error /// code otherwise. /// </returns> public virtual HouseArrestError house_arrest_client_start_service(iDeviceHandle device, out HouseArrestClientHandle client, string label) { HouseArrestError returnValue; returnValue = HouseArrestNativeMethods.house_arrest_client_start_service(device, out client, label); client.Api = this.Parent; return(returnValue); }
/// <summary> /// Starts a new AFC service on the specified device and connects to it. /// </summary> /// <param name="device"> /// The device to connect to. /// </param> /// <param name="client"> /// Pointer that will point to a newly allocated afc_client_t upon /// successful return. Must be freed using afc_client_free() after use. /// </param> /// <param name="label"> /// The label to use for communication. Usually the program name. /// Pass NULL to disable sending the label in requests to lockdownd. /// </param> /// <returns> /// AFC_E_SUCCESS on success, or an AFC_E_* error code otherwise. /// </returns> public virtual AfcError afc_client_start_service(iDeviceHandle device, out AfcClientHandle client, string label) { AfcError returnValue; returnValue = AfcNativeMethods.afc_client_start_service(device, out client, label); client.Api = this.Parent; return(returnValue); }