/// <summary>
/// Makes a connection to the AFC service on the 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 afc_client_t
/// upon successful return.
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success, AFC_E_INVALID_ARG if device or service is
/// invalid, AFC_E_MUX_ERROR if the connection cannot be established,
/// or AFC_E_NO_MEM if there is a memory allocation problem.
/// </returns>
public virtual AfcError afc_client_new(iDeviceHandle device, LockdownServiceDescriptorHandle service, out AfcClientHandle client)
{
AfcError returnValue;
returnValue = AfcNativeMethods.afc_client_new(device, service, out client);
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);
}
public static AfcError afc_read_directory(AfcClientHandle client, string path, out System.Collections.ObjectModel.ReadOnlyCollection <string> directoryInformation)
{
System.Runtime.InteropServices.ICustomMarshaler directoryInformationMarshaler = AfcDictionaryMarshaler.GetInstance(null);
System.IntPtr directoryInformationNative = System.IntPtr.Zero;
AfcError returnValue = AfcNativeMethods.afc_read_directory(client, path, out directoryInformationNative);
directoryInformation = ((System.Collections.ObjectModel.ReadOnlyCollection <string>)directoryInformationMarshaler.MarshalNativeToManaged(directoryInformationNative));
directoryInformationMarshaler.CleanUpNativeData(directoryInformationNative);
return(returnValue);
}
public static AfcError afc_get_device_info_key(AfcClientHandle client, string key, out string value)
{
System.Runtime.InteropServices.ICustomMarshaler valueMarshaler = NativeStringMarshaler.GetInstance(null);
System.IntPtr valueNative = System.IntPtr.Zero;
AfcError returnValue = AfcNativeMethods.afc_get_device_info_key(client, key, out valueNative);
value = ((string)valueMarshaler.MarshalNativeToManaged(valueNative));
valueMarshaler.CleanUpNativeData(valueNative);
return(returnValue);
}
public static AfcError afc_get_file_info(AfcClientHandle client, string filename, out System.Collections.ObjectModel.ReadOnlyCollection <string> fileInformation)
{
System.Runtime.InteropServices.ICustomMarshaler fileInformationMarshaler = AfcDictionaryMarshaler.GetInstance(null);
System.IntPtr fileInformationNative = System.IntPtr.Zero;
AfcError returnValue = AfcNativeMethods.afc_get_file_info(client, filename, out fileInformationNative);
fileInformation = ((System.Collections.ObjectModel.ReadOnlyCollection <string>)fileInformationMarshaler.MarshalNativeToManaged(fileInformationNative));
fileInformationMarshaler.CleanUpNativeData(fileInformationNative);
return(returnValue);
}
/// <summary>
/// Get a specific key of the device info list for a client connection.
/// Known key values are: Model, FSTotalBytes, FSFreeBytes and FSBlockSize.
/// This is a helper function for afc_get_device_info().
/// </summary>
/// <param name="client">
/// The client to get device info for.
/// </param>
/// <param name="key">
/// The key to get the value of.
/// </param>
/// <param name="value">
/// The value for the key if successful or NULL otherwise.
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
public virtual AfcError afc_get_device_info_key(AfcClientHandle client, string key, out string value)
{
return(AfcNativeMethods.afc_get_device_info_key(client, key, out value));
}
/// <summary>
/// Deletes a file or directory including possible contents.
/// </summary>
/// <param name="client">
/// The client to use.
/// </param>
/// <param name="path">
/// The path to delete. (must be a fully-qualified path)
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
/// <remarks>
/// Only available in iOS 6 and later.
/// </remarks>
public virtual AfcError afc_remove_path_and_contents(AfcClientHandle client, string path)
{
return(AfcNativeMethods.afc_remove_path_and_contents(client, path));
}
/// <summary>
/// Sets the modification time of a file on the device.
/// </summary>
/// <param name="client">
/// The client to use to set the file size.
/// </param>
/// <param name="path">
/// Path of the file for which the modification time should be set.
/// </param>
/// <param name="mtime">
/// The modification time to set in nanoseconds since epoch.
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
public virtual AfcError afc_set_file_time(AfcClientHandle client, string path, ulong mtime)
{
return(AfcNativeMethods.afc_set_file_time(client, path, mtime));
}
/// <summary>
/// Creates a hard link or symbolic link on the device.
/// </summary>
/// <param name="client">
/// The client to use for making a link
/// </param>
/// <param name="linktype">
/// 1 = hard link, 2 = symlink
/// </param>
/// <param name="target">
/// The file to be linked.
/// </param>
/// <param name="linkname">
/// The name of link.
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
public virtual AfcError afc_make_link(AfcClientHandle client, AfcLinkType linktype, string target, string linkname)
{
return(AfcNativeMethods.afc_make_link(client, linktype, target, linkname));
}
/// <summary>
/// Sets the size of a file on the device without prior opening it.
/// </summary>
/// <param name="client">
/// The client to use to set the file size.
/// </param>
/// <param name="path">
/// The path of the file to be truncated.
/// </param>
/// <param name="newsize">
/// The size to set the file to.
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
public virtual AfcError afc_truncate(AfcClientHandle client, string path, ulong newsize)
{
return(AfcNativeMethods.afc_truncate(client, path, newsize));
}
/// <summary>
/// Closes a file on the device.
/// </summary>
/// <param name="client">
/// The client to close the file with.
/// </param>
/// <param name="handle">
/// File handle of a previously opened file.
/// </param>
public virtual AfcError afc_file_close(AfcClientHandle client, ulong handle)
{
return(AfcNativeMethods.afc_file_close(client, handle));
}
/// <summary>
/// Gets a directory listing of the directory requested.
/// </summary>
/// <param name="client">
/// The client to get a directory listing from.
/// </param>
/// <param name="path">
/// The directory for listing. (must be a fully-qualified path)
/// </param>
/// <param name="directory_information">
/// A char list of files in the directory
/// terminated by an empty string or NULL if there was an error. Free with
/// afc_dictionary_free().
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
public virtual AfcError afc_read_directory(AfcClientHandle client, string path, out System.Collections.ObjectModel.ReadOnlyCollection <string> directoryInformation)
{
return(AfcNativeMethods.afc_read_directory(client, path, out directoryInformation));
}
/// <summary>
/// Seeks to a given position of a pre-opened file on the device.
/// </summary>
/// <param name="client">
/// The client to use to seek to the position.
/// </param>
/// <param name="handle">
/// File handle of a previously opened.
/// </param>
/// <param name="offset">
/// Seek offset.
/// </param>
/// <param name="whence">
/// Seeking direction, one of SEEK_SET, SEEK_CUR, or SEEK_END.
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
public virtual AfcError afc_file_seek(AfcClientHandle client, ulong handle, long offset, int whence)
{
return(AfcNativeMethods.afc_file_seek(client, handle, offset, whence));
}
/// <summary>
/// Returns current position in a pre-opened file on the device.
/// </summary>
/// <param name="client">
/// The client to use.
/// </param>
/// <param name="handle">
/// File handle of a previously opened file.
/// </param>
/// <param name="position">
/// Position in bytes of indicator
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
public virtual AfcError afc_file_tell(AfcClientHandle client, ulong handle, ref ulong position)
{
return(AfcNativeMethods.afc_file_tell(client, handle, ref position));
}
/// <summary>
/// Writes a given number of bytes to a file.
/// </summary>
/// <param name="client">
/// The client to use to write to the file.
/// </param>
/// <param name="handle">
/// File handle of previously opened file.
/// </param>
/// <param name="data">
/// The data to write to the file.
/// </param>
/// <param name="length">
/// How much data to write.
/// </param>
/// <param name="bytes_written">
/// The number of bytes actually written to the file.
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
public virtual AfcError afc_file_write(AfcClientHandle client, ulong handle, byte[] data, uint length, ref uint bytesWritten)
{
return(AfcNativeMethods.afc_file_write(client, handle, data, length, ref bytesWritten));
}
/// <summary>
/// Attempts to the read the given number of bytes from the given file.
/// </summary>
/// <param name="client">
/// The relevant AFC client
/// </param>
/// <param name="handle">
/// File handle of a previously opened file
/// </param>
/// <param name="data">
/// The pointer to the memory region to store the read data
/// </param>
/// <param name="length">
/// The number of bytes to read
/// </param>
/// <param name="bytes_read">
/// The number of bytes actually read.
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
public virtual AfcError afc_file_read(AfcClientHandle client, ulong handle, byte[] data, uint length, ref uint bytesRead)
{
return(AfcNativeMethods.afc_file_read(client, handle, data, length, ref bytesRead));
}
/// <summary>
/// Locks or unlocks a file on the device.
/// Makes use of flock on the device.
/// </summary>
/// <param name="client">
/// The client to lock the file with.
/// </param>
/// <param name="handle">
/// File handle of a previously opened file.
/// </param>
/// <param name="operation">
/// the lock or unlock operation to perform, this is one of
/// AFC_LOCK_SH (shared lock), AFC_LOCK_EX (exclusive lock), or
/// AFC_LOCK_UN (unlock).
/// </param>
public virtual AfcError afc_file_lock(AfcClientHandle client, ulong handle, AfcLockOp operation)
{
return(AfcNativeMethods.afc_file_lock(client, handle, operation));
}
/// <summary>
/// Frees up a char dictionary as returned by some AFC functions.
/// </summary>
/// <param name="dictionary">
/// The char array terminated by an empty string.
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
public virtual AfcError afc_dictionary_free(System.IntPtr dictionary)
{
return(AfcNativeMethods.afc_dictionary_free(dictionary));
}
/// <summary>
/// Get device information for a connected client. The device information
/// returned is the device model as well as the free space, the total capacity
/// and blocksize on the accessed disk partition.
/// </summary>
/// <param name="client">
/// The client to get device info for.
/// </param>
/// <param name="device_information">
/// A char list of device information terminated by an
/// empty string or NULL if there was an error. Free with
/// afc_dictionary_free().
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
public virtual AfcError afc_get_device_info(AfcClientHandle client, out System.Collections.ObjectModel.ReadOnlyCollection <string> deviceInformation)
{
return(AfcNativeMethods.afc_get_device_info(client, out deviceInformation));
}
/// <summary>
/// Gets information about a specific file.
/// </summary>
/// <param name="client">
/// The client to use to get the information of the file.
/// </param>
/// <param name="filename">
/// The fully-qualified path to the file.
/// </param>
/// <param name="file_information">
/// Pointer to a buffer that will be filled with a
/// NULL-terminated list of strings with the file information. Set to NULL
/// before calling this function. Free with afc_dictionary_free().
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
public virtual AfcError afc_get_file_info(AfcClientHandle client, string filename, out System.Collections.ObjectModel.ReadOnlyCollection <string> fileInformation)
{
return(AfcNativeMethods.afc_get_file_info(client, filename, out fileInformation));
}
/// <summary>
/// Creates a directory on the device.
/// </summary>
/// <param name="client">
/// The client to use to make a directory.
/// </param>
/// <param name="path">
/// The directory's path. (must be a fully-qualified path, I assume
/// all other mkdir restrictions apply as well)
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
public virtual AfcError afc_make_directory(AfcClientHandle client, string path)
{
return(AfcNativeMethods.afc_make_directory(client, path));
}
/// <summary>
/// Sets the size of a file on the device.
/// </summary>
/// <param name="client">
/// The client to use to set the file size.
/// </param>
/// <param name="handle">
/// File handle of a previously opened file.
/// </param>
/// <param name="newsize">
/// The size to set the file to.
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
/// <remarks>
/// This function is more akin to ftruncate than truncate, and truncate
/// calls would have to open the file before calling this, sadly.
/// </remarks>
public virtual AfcError afc_file_truncate(AfcClientHandle client, ulong handle, ulong newsize)
{
return(AfcNativeMethods.afc_file_truncate(client, handle, newsize));
}
/// <summary>
/// Opens a file on the device.
/// </summary>
/// <param name="client">
/// The client to use to open the file.
/// </param>
/// <param name="filename">
/// The file to open. (must be a fully-qualified path)
/// </param>
/// <param name="file_mode">
/// The mode to use to open the file.
/// </param>
/// <param name="handle">
/// Pointer to a uint64_t that will hold the handle of the file
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
public virtual AfcError afc_file_open(AfcClientHandle client, string filename, AfcFileMode fileMode, ref ulong handle)
{
return(AfcNativeMethods.afc_file_open(client, filename, fileMode, ref handle));
}
/// <summary>
/// Renames a file or directory on the device.
/// </summary>
/// <param name="client">
/// The client to have rename.
/// </param>
/// <param name="from">
/// The name to rename from. (must be a fully-qualified path)
/// </param>
/// <param name="to">
/// The new name. (must also be a fully-qualified path)
/// </param>
/// <returns>
/// AFC_E_SUCCESS on success or an AFC_E_* error value.
/// </returns>
public virtual AfcError afc_rename_path(AfcClientHandle client, string from, string to)
{
return(AfcNativeMethods.afc_rename_path(client, from, to));
}
/// <summary>
/// Frees up an AFC client. If the connection was created by the client itself,
/// the connection will be closed.
/// </summary>
/// <param name="client">
/// The client to free.
/// </param>
public virtual AfcError afc_client_free(System.IntPtr client)
{
return(AfcNativeMethods.afc_client_free(client));
}
