You've already forked UnrealEngineUWP
mirror of
https://github.com/izzy2lost/UnrealEngineUWP.git
synced 2026-03-26 18:15:20 -07:00
cd31c680dc
#jira UE-78709 #rb Anthony.Bills #fyi Anthony.Bills, Peter.Sauerbrei #lockdown Cristina.Riveron [CL 9469493 by Jack Porter in 4.23 branch]
3411 lines
126 KiB
C#
3411 lines
126 KiB
C#
//
|
|
// Copyright (c) 2007, Peter Dennis Bartok <PeterDennisBartok@gmail.com>
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use of this software in source and binary forms, with or without modification, are
|
|
// permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistributions of source code must retain the above
|
|
// copyright notice, this list of conditions and the
|
|
// following disclaimer.
|
|
//
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the
|
|
// following disclaimer in the documentation and/or other
|
|
// materials provided with the distribution.
|
|
//
|
|
// * Neither the name of Peter Dennis Bartok nor the names of its
|
|
// contributors may be used to endorse or promote products
|
|
// derived from this software without specific prior
|
|
// written permission of Yahoo! Inc.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
|
|
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
|
|
// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
|
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
|
|
// TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
|
|
//
|
|
// Based on code developed by geohot, ixtli, nightwatch, warren
|
|
// See http://iphone.fiveforty.net/wiki/index.php?title=Main_Page
|
|
//
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using Microsoft.Win32;
|
|
using MobileDeviceInterface;
|
|
|
|
namespace Manzana
|
|
{
|
|
/// <summary>
|
|
/// Structures with unknown innards. They should only ever be used as the target of a TypedPtr, never inspected.
|
|
/// </summary>
|
|
public class AppleMobileDeviceConnection { }
|
|
|
|
/// <summary>
|
|
/// Structures with unknown innards. They should only ever be used as the target of a TypedPtr, never inspected.
|
|
/// </summary>
|
|
public class AFCCommConnection { }
|
|
|
|
public class AFCDictionary { }
|
|
|
|
/// <summary>
|
|
/// Provides the fields representing the type of notification
|
|
/// </summary>
|
|
public enum NotificationMessage
|
|
{
|
|
/// <summary>The iPhone was connected to the computer.</summary>
|
|
Connected = 1,
|
|
|
|
/// <summary>The iPhone was disconnected from the computer.</summary>
|
|
Disconnected = 2,
|
|
|
|
/// <summary>Notification from the iPhone occurred, but the type is unknown.</summary>
|
|
Unknown = 3,
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
|
|
internal struct AMDeviceNotificationCallbackInfo
|
|
{
|
|
public IntPtr dev
|
|
{
|
|
get
|
|
{
|
|
return dev_ptr;
|
|
}
|
|
}
|
|
internal IntPtr dev_ptr;
|
|
public NotificationMessage msg;
|
|
}
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
|
|
internal struct AMRecoveryDevice
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
|
|
public byte[] unknown0; /* 0 */
|
|
public DeviceRestoreNotificationCallback callback; /* 8 */
|
|
public IntPtr user_info; /* 12 */
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
|
|
public byte[] unknown1; /* 16 */
|
|
public uint readwrite_pipe; /* 28 */
|
|
public byte read_pipe; /* 32 */
|
|
public byte write_ctrl_pipe; /* 33 */
|
|
public byte read_unknown_pipe; /* 34 */
|
|
public byte write_file_pipe; /* 35 */
|
|
public byte write_input_pipe; /* 36 */
|
|
};
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
internal delegate void DeviceNotificationCallback(ref AMDeviceNotificationCallbackInfo callback_info);
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
internal delegate void DeviceRestoreNotificationCallback(ref AMRecoveryDevice callback_info);
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
|
|
internal delegate void DeviceInstallationCallback(IntPtr/*CFDictionary*/ UntypedStatusDict, IntPtr UserData);
|
|
|
|
public interface ICoreFoundationRunLoop
|
|
{
|
|
int RunLoopInMode(IntPtr mode, double seconds, int returnAfterSourceHandled);
|
|
IntPtr DefaultMode();
|
|
}
|
|
|
|
internal class CoreFoundationRunLoopOSX : ICoreFoundationRunLoop
|
|
{
|
|
public int RunLoopInMode(IntPtr mode, double seconds, int returnAfterSourceHandled)
|
|
{
|
|
return CFRunLoopRunInMode(mode, seconds, returnAfterSourceHandled);
|
|
}
|
|
|
|
public IntPtr DefaultMode()
|
|
{
|
|
return kCFRunLoopDefaultMode;
|
|
}
|
|
|
|
[DllImport("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation")]
|
|
public extern static IntPtr CFStringCreateWithCString(IntPtr allocator, string value, int encoding);
|
|
|
|
[DllImport("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation")]
|
|
public extern static void CFRunLoopRun();
|
|
|
|
[DllImport("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation")]
|
|
public extern static IntPtr CFRunLoopGetMain();
|
|
|
|
[DllImport("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation")]
|
|
public extern static IntPtr CFRunLoopGetCurrent();
|
|
|
|
[DllImport("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation")]
|
|
public extern static int CFRunLoopRunInMode(IntPtr mode, double seconds, int returnAfterSourceHandled);
|
|
|
|
public static IntPtr kCFRunLoopDefaultMode = CFStringCreateWithCString(IntPtr.Zero, "kCFRunLoopDefaultMode", 0);
|
|
}
|
|
|
|
internal class CoreFoundationRunLoopWin32 : ICoreFoundationRunLoop
|
|
{
|
|
static CoreFoundationRunLoopWin32()
|
|
{
|
|
}
|
|
|
|
public int RunLoopInMode(IntPtr mode, double seconds, int returnAfterSourceHandled)
|
|
{
|
|
return CFRunLoopRunInMode(mode, seconds, returnAfterSourceHandled);
|
|
}
|
|
|
|
public IntPtr DefaultMode()
|
|
{
|
|
return kCFRunLoopDefaultMode;
|
|
}
|
|
|
|
[DllImport("CoreFoundation.dll")]
|
|
public extern static IntPtr CFStringCreateWithCString(IntPtr allocator, string value, int encoding);
|
|
|
|
[DllImport("CoreFoundation.dll")]
|
|
public extern static void CFRunLoopRun();
|
|
|
|
[DllImport("CoreFoundation.dll")]
|
|
public extern static IntPtr CFRunLoopGetMain();
|
|
|
|
[DllImport("CoreFoundation.dll")]
|
|
public extern static IntPtr CFRunLoopGetCurrent();
|
|
|
|
[DllImport("CoreFoundation.dll")]
|
|
public extern static int CFRunLoopRunInMode(IntPtr mode, double seconds, int returnAfterSourceHandled);
|
|
|
|
public static IntPtr kCFRunLoopDefaultMode = CFStringCreateWithCString(IntPtr.Zero, "kCFRunLoopDefaultMode", 0);
|
|
}
|
|
|
|
public static class ITunesFinder
|
|
{
|
|
public static string FindWindowsStoreITunesInstallPath()
|
|
{
|
|
string InstallPath = null;
|
|
string PackagesKeyName = "Software\\Classes\\Local Settings\\Software\\Microsoft\\Windows\\CurrentVersion\\AppModel\\PackageRepository\\Packages";
|
|
|
|
RegistryKey PackagesKey = Registry.LocalMachine.OpenSubKey(PackagesKeyName);
|
|
|
|
if (PackagesKey != null)
|
|
{
|
|
string[] PackageSubKeyNames = PackagesKey.GetSubKeyNames();
|
|
|
|
foreach (string PackageSubKeyName in PackageSubKeyNames)
|
|
{
|
|
if (PackageSubKeyName.Contains("AppleInc.iTunes") && (PackageSubKeyName.Contains("_x64") || PackageSubKeyName.Contains("_x86")))
|
|
{
|
|
string FullPackageSubKeyName = PackagesKeyName + "\\" + PackageSubKeyName;
|
|
|
|
RegistryKey iTunesKey = Registry.LocalMachine.OpenSubKey(FullPackageSubKeyName);
|
|
if (iTunesKey != null)
|
|
{
|
|
InstallPath = (string)iTunesKey.GetValue("Path");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return InstallPath;
|
|
}
|
|
|
|
public static string FindWindowsStoreITunesDLL()
|
|
{
|
|
string DllPath = null;
|
|
|
|
string InstallPath = FindWindowsStoreITunesInstallPath();
|
|
|
|
if (InstallPath != null)
|
|
{
|
|
DllPath = InstallPath + "\\AMDS32\\MobileDevice.dll";
|
|
|
|
// There's also a 64-bit version here, but it seems that our c# programs are 32-bit
|
|
// DllPath = InstallPath + "\\AMDS64\\MobileDevice.dll";
|
|
}
|
|
|
|
return DllPath;
|
|
}
|
|
}
|
|
|
|
public class CoreFoundationRunLoop
|
|
{
|
|
static public ICoreFoundationRunLoop CoreImpl;
|
|
|
|
static CoreFoundationRunLoop()
|
|
{
|
|
if (Environment.OSVersion.Platform == PlatformID.MacOSX || Environment.OSVersion.Platform == PlatformID.Unix)
|
|
{
|
|
CoreImpl = new CoreFoundationRunLoopOSX();
|
|
}
|
|
else
|
|
{
|
|
List<string> PathBits = new List<string>();
|
|
PathBits.Add(Environment.GetEnvironmentVariable("Path"));
|
|
|
|
// Try to add the paths from the registry (they aren't always available on newer iTunes installs though)
|
|
object RegistrySupportDir = Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Apple Inc.\Apple Application Support", "InstallDir", Environment.CurrentDirectory);
|
|
if (RegistrySupportDir != null)
|
|
{
|
|
DirectoryInfo ApplicationSupportDirectory = new DirectoryInfo(RegistrySupportDir.ToString());
|
|
|
|
if (ApplicationSupportDirectory.Exists)
|
|
{
|
|
PathBits.Add(ApplicationSupportDirectory.FullName);
|
|
}
|
|
}
|
|
|
|
string ITunesInstallPath = ITunesFinder.FindWindowsStoreITunesInstallPath();
|
|
if(ITunesInstallPath != null)
|
|
{
|
|
DirectoryInfo iTunesInstallDirectory = new DirectoryInfo(ITunesInstallPath);
|
|
|
|
if (iTunesInstallDirectory.Exists)
|
|
{
|
|
PathBits.Add(iTunesInstallDirectory.FullName);
|
|
PathBits.Add(ITunesFinder.FindWindowsStoreITunesInstallPath() + "\\VFS\\ProgramFilesCommonX86\\Apple\\Apple Application Support");
|
|
}
|
|
}
|
|
|
|
// Add some guesses as well
|
|
DirectoryInfo AppleMobileDeviceSupport = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.CommonProgramFiles) + @"\Apple\Mobile Device Support");
|
|
if (AppleMobileDeviceSupport.Exists)
|
|
{
|
|
PathBits.Add(AppleMobileDeviceSupport.FullName);
|
|
}
|
|
|
|
DirectoryInfo AppleMobileDeviceSupportX86 = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.CommonProgramFilesX86) + @"\Apple\Mobile Device Support");
|
|
if ((AppleMobileDeviceSupport != AppleMobileDeviceSupportX86) && (AppleMobileDeviceSupportX86.Exists))
|
|
{
|
|
PathBits.Add(AppleMobileDeviceSupportX86.FullName);
|
|
}
|
|
|
|
// Set the path from all the individual bits
|
|
Environment.SetEnvironmentVariable("Path", string.Join(";", PathBits));
|
|
CoreImpl = new CoreFoundationRunLoopWin32();
|
|
}
|
|
}
|
|
|
|
public static int RunLoopRunInMode(IntPtr mode, double seconds, int returnAfterSourceHandled)
|
|
{
|
|
return CoreImpl.RunLoopInMode(mode, seconds, returnAfterSourceHandled);
|
|
}
|
|
|
|
public static IntPtr kCFRunLoopDefaultMode()
|
|
{
|
|
return CoreImpl.DefaultMode();
|
|
}
|
|
}
|
|
|
|
internal interface MobileDeviceImpl
|
|
{
|
|
int NotificationSubscribe(DeviceNotificationCallback DeviceCallbackHandle);
|
|
IntPtr CopyDeviceIdentifier(TypedPtr<AppleMobileDeviceConnection> device);
|
|
int Connect(TypedPtr<AppleMobileDeviceConnection> device);
|
|
IntPtr CopyValue(TypedPtr<AppleMobileDeviceConnection> device, uint unknown, TypedPtr<CFString> cfstring);
|
|
int Disconnect(TypedPtr<AppleMobileDeviceConnection> device);
|
|
int GetConnectionID(TypedPtr<AppleMobileDeviceConnection> device);
|
|
int IsPaired(TypedPtr<AppleMobileDeviceConnection> device);
|
|
int Pair(TypedPtr<AppleMobileDeviceConnection> device);
|
|
int Unpair(TypedPtr<AppleMobileDeviceConnection> device);
|
|
int ValidatePairing(TypedPtr<AppleMobileDeviceConnection> device);
|
|
int LookupApplications(TypedPtr<AppleMobileDeviceConnection> device, IntPtr options, out Dictionary<string, object> AppBundles);
|
|
int StartSession(TypedPtr<AppleMobileDeviceConnection> device);
|
|
int StopSession(TypedPtr<AppleMobileDeviceConnection> device);
|
|
int StartHouseArrestService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> bundleName, IntPtr unknown1, ref IntPtr handle, int unknown2);
|
|
int CreateHouseArrestService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> bundleName, IntPtr unknown1, out TypedPtr<AFCCommConnection> conn);
|
|
int StartService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> serviceName, ref IntPtr handle, IntPtr unknown);
|
|
int SecureStartService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> serviceName, int flagsPassInZero, ref IntPtr handle);
|
|
string ServiceConnectionReceive(IntPtr handle);
|
|
int SocketSend(IntPtr fd, IntPtr buf, int count);
|
|
void SocketClose(IntPtr fd);
|
|
int USBMuxConnectByPort(int DeviceID, short iPort, ref IntPtr outHandle);
|
|
int RestoreRegisterForDeviceNotifications(
|
|
DeviceRestoreNotificationCallback dfu_connect,
|
|
DeviceRestoreNotificationCallback recovery_connect,
|
|
DeviceRestoreNotificationCallback dfu_disconnect,
|
|
DeviceRestoreNotificationCallback recovery_disconnect,
|
|
uint unknown0,
|
|
IntPtr user_info);
|
|
int SecureUninstallApplication(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFString> ApplicationIdentifer,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
int SecureTransferPath(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
int SecureInstallApplication(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
int SecureUpgradeApplication(
|
|
IntPtr ServiceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
int ConnectionClose(TypedPtr<AFCCommConnection> conn);
|
|
int ConnectionInvalidate(TypedPtr<AFCCommConnection> conn);
|
|
int ConnectionIsValid(TypedPtr<AFCCommConnection> conn);
|
|
int ConnectionOpen(IntPtr handle, uint io_timeout, out TypedPtr<AFCCommConnection> OutConn);
|
|
int DeviceInfoOpen(IntPtr handle, ref IntPtr dict);
|
|
int DirectoryClose(TypedPtr<AFCCommConnection> conn, IntPtr dir);
|
|
int DirectoryCreate(TypedPtr<AFCCommConnection> conn, string path);
|
|
int DirectoryRead(TypedPtr<AFCCommConnection> conn, IntPtr dir, ref IntPtr dirent);
|
|
int FileInfoOpen(TypedPtr<AFCCommConnection> conn, string path, out TypedPtr<AFCDictionary> OutDict);
|
|
int FileRefClose(TypedPtr<AFCCommConnection> conn, Int64 handle);
|
|
int FileRefOpen(TypedPtr<AFCCommConnection> conn, string path, Int64 mode, out Int64 handle);
|
|
int FileRefRead(TypedPtr<AFCCommConnection> conn, Int64 handle, byte[] buffer, ref uint len);
|
|
int FileRefSeek(TypedPtr<AFCCommConnection> conn, Int64 handle, Int64 pos, Int64 origin);
|
|
int FileRefSetFileSize(TypedPtr<AFCCommConnection> conn, Int64 handle, uint size);
|
|
int FileRefTell(TypedPtr<AFCCommConnection> conn, Int64 handle, ref uint position);
|
|
int FileRefWrite(TypedPtr<AFCCommConnection> conn, Int64 handle, byte[] buffer, uint len);
|
|
int FlushData(TypedPtr<AFCCommConnection> conn, Int64 handle);
|
|
int KeyValueClose(TypedPtr<AFCDictionary> dict);
|
|
int KeyValueRead(TypedPtr<AFCDictionary> dict, out IntPtr key, out IntPtr val);
|
|
int RemovePath(TypedPtr<AFCCommConnection> conn, string path);
|
|
int RenamePath(TypedPtr<AFCCommConnection> conn, string OldPath, string NewPath);
|
|
int DirectoryOpen(TypedPtr<AFCCommConnection> conn, string path, ref IntPtr dir);
|
|
int DirectoryRead(TypedPtr<AFCCommConnection> conn, IntPtr dir, ref string buffer);
|
|
}
|
|
|
|
internal class MobileDeviceOSX : MobileDeviceImpl
|
|
{
|
|
// static readonly int ForceStaticInit = 42;
|
|
const string DLLName = "/System/Library/PrivateFrameworks/MobileDevice.framework/Versions/A/MobileDevice";
|
|
|
|
public int NotificationSubscribe(DeviceNotificationCallback DeviceCallbackHandle)
|
|
{
|
|
return AMDeviceMethods.NotificationSubscribe(DeviceCallbackHandle);
|
|
}
|
|
|
|
public IntPtr CopyDeviceIdentifier(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.CopyDeviceIdentifier(device);
|
|
}
|
|
|
|
public int Connect(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.Connect(device);
|
|
}
|
|
|
|
public IntPtr CopyValue(TypedPtr<AppleMobileDeviceConnection> device, uint unknown, TypedPtr<CFString> cfstring)
|
|
{
|
|
return AMDeviceMethods.CopyValue(device, unknown, cfstring);
|
|
}
|
|
|
|
public int Disconnect(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.Disconnect(device);
|
|
}
|
|
|
|
public int GetConnectionID(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.GetConnectionID(device);
|
|
}
|
|
|
|
public int IsPaired(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.IsPaired(device);
|
|
}
|
|
|
|
public int Pair(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.Pair(device);
|
|
}
|
|
|
|
public int Unpair(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.Unpair(device);
|
|
}
|
|
|
|
public int ValidatePairing(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.ValidatePairing(device);
|
|
}
|
|
|
|
public int LookupApplications(TypedPtr<AppleMobileDeviceConnection> device, IntPtr options, out Dictionary<string, object> AppBundles)
|
|
{
|
|
int Result = AMDeviceMethods.LookupApplications(device, options, out AppBundles);
|
|
return Result;
|
|
}
|
|
|
|
public int StartSession(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.StartSession((IntPtr)device);
|
|
}
|
|
|
|
public int StopSession(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.StopSession((IntPtr)device);
|
|
}
|
|
|
|
public int StartHouseArrestService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> bundleName, IntPtr unknown1, ref IntPtr handle, int unknown2)
|
|
{
|
|
return AMDeviceMethods.StartHouseArrestService((IntPtr)device, (IntPtr)bundleName, unknown1, ref handle, unknown2);
|
|
}
|
|
|
|
public int CreateHouseArrestService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> bundleName, IntPtr unknown1, out TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AMDeviceMethods.CreateHouseArrestService((IntPtr)device, (IntPtr)bundleName, unknown1, out conn);
|
|
}
|
|
|
|
public int StartService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> serviceName, ref IntPtr handle, IntPtr unknown)
|
|
{
|
|
return AMDeviceMethods.StartService((IntPtr)device, (IntPtr)serviceName, ref handle, unknown);
|
|
}
|
|
|
|
public int SecureStartService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> serviceName, int flagsPassInZero, ref IntPtr handle)
|
|
{
|
|
return AMDeviceMethods.SecureStartService((IntPtr)device, (IntPtr)serviceName, flagsPassInZero, ref handle);
|
|
}
|
|
|
|
public string ServiceConnectionReceive(IntPtr handle)
|
|
{
|
|
return AMDeviceMethods.ServiceConnectionReceive(handle);
|
|
}
|
|
|
|
[DllImport("libMonoPosixHelper.dylib", SetLastError = true, EntryPoint = "Mono_Posix_Syscall_write")]
|
|
public static extern long write(IntPtr fd, IntPtr buf, ulong count);
|
|
|
|
public int SocketSend(IntPtr fd, IntPtr buf, int count)
|
|
{
|
|
return (int)write(fd, buf, (ulong)count);
|
|
}
|
|
|
|
[DllImport("libikvm-native.dylib", SetLastError = true)]
|
|
public static extern int close(IntPtr fd);
|
|
public void SocketClose(IntPtr fd)
|
|
{
|
|
close(fd);
|
|
}
|
|
|
|
public int RestoreRegisterForDeviceNotifications(
|
|
DeviceRestoreNotificationCallback dfu_connect,
|
|
DeviceRestoreNotificationCallback recovery_connect,
|
|
DeviceRestoreNotificationCallback dfu_disconnect,
|
|
DeviceRestoreNotificationCallback recovery_disconnect,
|
|
uint unknown0,
|
|
IntPtr user_info)
|
|
{
|
|
return AMDeviceMethods.AMRestoreRegisterForDeviceNotifications(dfu_connect, recovery_connect, dfu_disconnect, recovery_disconnect, unknown0, user_info);
|
|
}
|
|
|
|
public int SecureUninstallApplication(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFString> ApplicationIdentifer,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceMethods.SecureUninstallApplication(serviceConnection, DeviceIfConnIsNull, ApplicationIdentifer, ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public int SecureTransferPath(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceMethods.SecureTransferPath(serviceConnection, DeviceIfConnIsNull, UrlPath, ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public int SecureInstallApplication(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceMethods.SecureInstallApplication(serviceConnection, DeviceIfConnIsNull, UrlPath, ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public int SecureUpgradeApplication(
|
|
IntPtr ServiceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceMethods.SecureUpgradeApplication(ServiceConnection, DeviceIfConnIsNull, UrlPath, ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public int ConnectionClose(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFC.ConnectionClose(conn);
|
|
}
|
|
|
|
public int ConnectionInvalidate(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFC.ConnectionInvalidate(conn);
|
|
}
|
|
|
|
public int ConnectionIsValid(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFC.ConnectionIsValid(conn);
|
|
}
|
|
|
|
public int ConnectionOpen(IntPtr handle, uint io_timeout, out TypedPtr<AFCCommConnection> OutConn)
|
|
{
|
|
return AFC.ConnectionOpen(handle, io_timeout, out OutConn);
|
|
}
|
|
|
|
public int DeviceInfoOpen(IntPtr handle, ref IntPtr dict)
|
|
{
|
|
return AFC.DeviceInfoOpen(handle, ref dict);
|
|
}
|
|
|
|
public int DirectoryClose(TypedPtr<AFCCommConnection> conn, IntPtr dir)
|
|
{
|
|
return AFC.DirectoryClose(conn, dir);
|
|
}
|
|
|
|
public int DirectoryCreate(TypedPtr<AFCCommConnection> conn, string path)
|
|
{
|
|
return AFC.DirectoryCreate(conn, path);
|
|
}
|
|
|
|
public int DirectoryOpen(TypedPtr<AFCCommConnection> conn, string path, ref IntPtr dir)
|
|
{
|
|
return AFC.DirectoryOpen(conn, path, ref dir);
|
|
}
|
|
|
|
public int DirectoryRead(TypedPtr<AFCCommConnection> conn, IntPtr dir, ref IntPtr dirent)
|
|
{
|
|
return AFC.DirectoryRead(conn, dir, ref dirent);
|
|
}
|
|
|
|
public int FileInfoOpen(TypedPtr<AFCCommConnection> conn, string path, out TypedPtr<AFCDictionary> OutDict)
|
|
{
|
|
return AFC.FileInfoOpen(conn, path, out OutDict);
|
|
}
|
|
|
|
public int FileRefClose(TypedPtr<AFCCommConnection> conn, Int64 handle)
|
|
{
|
|
return AFC.FileRefClose(conn, handle);
|
|
}
|
|
|
|
public int FileRefOpen(TypedPtr<AFCCommConnection> conn, string path, Int64 mode, out Int64 handle)
|
|
{
|
|
return AFC.FileRefOpen(conn, path, mode, out handle);
|
|
}
|
|
|
|
public int FileRefRead(TypedPtr<AFCCommConnection> conn, Int64 handle, byte[] buffer, ref uint len)
|
|
{
|
|
return AFC.FileRefRead(conn, handle, buffer, ref len);
|
|
}
|
|
|
|
public int FileRefSeek(TypedPtr<AFCCommConnection> conn, Int64 handle, Int64 pos, Int64 origin)
|
|
{
|
|
return AFC.FileRefSeek(conn, handle, pos, origin);
|
|
}
|
|
|
|
public int FileRefSetFileSize(TypedPtr<AFCCommConnection> conn, Int64 handle, uint size)
|
|
{
|
|
return AFC.FileRefSetFileSize(conn, handle, size);
|
|
}
|
|
|
|
public int FileRefTell(TypedPtr<AFCCommConnection> conn, Int64 handle, ref uint position)
|
|
{
|
|
return AFC.FileRefTell(conn, handle, ref position);
|
|
}
|
|
|
|
public int FileRefWrite(TypedPtr<AFCCommConnection> conn, Int64 handle, byte[] buffer, uint len)
|
|
{
|
|
return AFC.FileRefWrite(conn, handle, buffer, len);
|
|
}
|
|
|
|
public int FlushData(TypedPtr<AFCCommConnection> conn, Int64 handle)
|
|
{
|
|
return AFC.FlushData(conn, handle);
|
|
}
|
|
|
|
public int KeyValueClose(TypedPtr<AFCDictionary> dict)
|
|
{
|
|
return AFC.KeyValueClose(dict);
|
|
}
|
|
|
|
public int KeyValueRead(TypedPtr<AFCDictionary> dict, out IntPtr key, out IntPtr val)
|
|
{
|
|
return AFC.KeyValueRead(dict, out key, out val);
|
|
}
|
|
|
|
public int RemovePath(TypedPtr<AFCCommConnection> conn, string path)
|
|
{
|
|
return AFC.RemovePath(conn, path);
|
|
}
|
|
|
|
public int RenamePath(TypedPtr<AFCCommConnection> conn, string OldPath, string NewPath)
|
|
{
|
|
return AFC.RenamePath(conn, OldPath, NewPath);
|
|
}
|
|
|
|
public int USBMuxConnectByPort(int DeviceID, short iPort, ref IntPtr outHandle)
|
|
{
|
|
return AFC.USBConnectByPort(DeviceID, iPort, ref outHandle);
|
|
}
|
|
|
|
#region Application Methods
|
|
public class AMDeviceMethods
|
|
{
|
|
// Need to have the path manipulation code in static MobileDevice() to run
|
|
// static int ForceMobileDeviceConstructorToRun;
|
|
static AMDeviceMethods()
|
|
{
|
|
// ForceMobileDeviceConstructorToRun = ForceStaticInit;
|
|
}
|
|
|
|
public static IntPtr CopyDeviceIdentifier(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceCopyDeviceIdentifier((IntPtr)device);
|
|
}
|
|
|
|
public static int Connect(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceConnect((IntPtr)device);
|
|
}
|
|
|
|
public static IntPtr CopyValue(TypedPtr<AppleMobileDeviceConnection> device, uint unknown, TypedPtr<CFString> cfstring)
|
|
{
|
|
return AMDeviceCopyValue((IntPtr)device, unknown, (IntPtr)cfstring);
|
|
}
|
|
|
|
public static int Disconnect(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceDisconnect((IntPtr)device);
|
|
}
|
|
|
|
public static int GetConnectionID(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceGetConnectionID((IntPtr)device);
|
|
}
|
|
|
|
public static int IsPaired(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceIsPaired((IntPtr)device);
|
|
}
|
|
|
|
public static int Pair(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDevicePair((IntPtr)device);
|
|
}
|
|
|
|
public static int Unpair(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceUnpair((IntPtr)device);
|
|
}
|
|
|
|
public static int ValidatePairing(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceValidatePairing((IntPtr)device);
|
|
}
|
|
|
|
public static int LookupApplications(TypedPtr<AppleMobileDeviceConnection> device, IntPtr options, out Dictionary<string, object> AppBundles)
|
|
{
|
|
IntPtr UntypedDict = IntPtr.Zero;
|
|
int Result = AMDeviceLookupApplications((IntPtr)device, options, ref UntypedDict);
|
|
|
|
AppBundles = MobileDevice.ConvertCFDictionaryToDictionaryString(new TypedPtr<CFDictionary>(UntypedDict));
|
|
|
|
return Result;
|
|
}
|
|
|
|
public static int StartSession(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceStartSession((IntPtr)device);
|
|
}
|
|
|
|
public static int StopSession(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceStopSession((IntPtr)device);
|
|
}
|
|
|
|
public static int StartHouseArrestService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> bundleName, IntPtr unknown1, ref IntPtr handle, int unknown2)
|
|
{
|
|
return AMDeviceStartHouseArrestService((IntPtr)device, (IntPtr)bundleName, unknown1, ref handle, unknown2);
|
|
}
|
|
|
|
public static int CreateHouseArrestService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> bundleName, IntPtr unknown1, out TypedPtr<AFCCommConnection> OutConn)
|
|
{
|
|
IntPtr Conn;
|
|
int Result = AMDeviceCreateHouseArrestService((IntPtr)device, (IntPtr)bundleName, unknown1, out Conn);
|
|
OutConn = Conn;
|
|
return Result;
|
|
}
|
|
|
|
public static int StartService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> serviceName, ref IntPtr handle, IntPtr unknown)
|
|
{
|
|
return AMDeviceStartService((IntPtr)device, (IntPtr)serviceName, ref handle, unknown);
|
|
}
|
|
|
|
public static int SecureStartService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> serviceName, int flagsPassInZero, ref IntPtr handle)
|
|
{
|
|
return AMDeviceSecureStartService((IntPtr)device, (IntPtr)serviceName, flagsPassInZero, ref handle);
|
|
}
|
|
|
|
|
|
public static string ServiceConnectionReceive(IntPtr handle)
|
|
{
|
|
byte[] Buffer = new byte[1024];
|
|
|
|
IntPtr UnmanagedPointer = Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0);
|
|
int Ret = AMDServiceConnectionReceive(handle, UnmanagedPointer, 1023, 0);
|
|
Buffer[Ret] = 0;
|
|
int Start = 0;
|
|
string Result = "";
|
|
int I;
|
|
for (I = 0; I < Ret; I++)
|
|
{
|
|
if (Buffer[I] == 0)
|
|
{
|
|
Result += System.Text.Encoding.UTF8.GetString(Buffer, Start, I - Start);
|
|
Start = I + 1;
|
|
}
|
|
}
|
|
if (I > Start)
|
|
{
|
|
Result += System.Text.Encoding.UTF8.GetString(Buffer, Start, I - Start);
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
public static int UninstallApplication(
|
|
TypedPtr<AppleMobileDeviceConnection> device,
|
|
TypedPtr<CFString> ApplicationIdentifier,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceUninstallApplication((IntPtr)device, (IntPtr)ApplicationIdentifier, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int SecureUninstallApplication(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFString> ApplicationIdentifer,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceSecureUninstallApplication(serviceConnection, (IntPtr)DeviceIfConnIsNull, (IntPtr)ApplicationIdentifer, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int SecureTransferPath(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceSecureTransferPath(serviceConnection, (IntPtr)DeviceIfConnIsNull, (IntPtr)UrlPath, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int SecureInstallApplication(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceSecureInstallApplication(serviceConnection, (IntPtr)DeviceIfConnIsNull, (IntPtr)UrlPath, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int TransferApplication(
|
|
TypedPtr<AppleMobileDeviceConnection> device,
|
|
TypedPtr<CFString> InPackagePath,
|
|
IntPtr UnknownButUnused,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceTransferApplication((IntPtr)device, (IntPtr)InPackagePath, UnknownButUnused, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int SecureUpgradeApplication(
|
|
IntPtr ServiceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceSecureUpgradeApplication(ServiceConnection, (IntPtr)DeviceIfConnIsNull, (IntPtr)UrlPath, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int InstallApplication(
|
|
TypedPtr<AppleMobileDeviceConnection> device,
|
|
TypedPtr<CFString> FilePath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceInstallApplication((IntPtr)device, (IntPtr)FilePath, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int NotificationSubscribe(DeviceNotificationCallback DeviceCallbackHandle)
|
|
{
|
|
IntPtr notification;
|
|
return AMDeviceNotificationSubscribe(DeviceCallbackHandle, 0, 0, 0, out notification);
|
|
}
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static IntPtr AMDeviceCopyDeviceIdentifier(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceConnect(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static IntPtr AMDeviceCopyValue(IntPtr/*AppleMobileDeviceConnection*/ device, uint unknown, IntPtr/*CFString*/ cfstring);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceDisconnect(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceGetConnectionID(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceIsPaired(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDevicePair(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceUnpair(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceValidatePairing(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceLookupApplications(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr options, ref IntPtr appBundles);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceNotificationSubscribe(DeviceNotificationCallback callback, uint unused1, uint unused2, uint unused3, out IntPtr am_device_notification_ptr);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceStartHouseArrestService(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr/*CFString*/ bundleName, IntPtr unknown1, ref IntPtr handle, int unknown2);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceCreateHouseArrestService(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr/*CFString*/ bundleName, IntPtr unknown1, out IntPtr conn);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceStartService(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr/*CFString*/ serviceName, ref IntPtr handle, IntPtr unknown);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceSecureStartService(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr/*CFString*/ serviceName, int flagsPassInZero, ref IntPtr handle);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDServiceConnectionReceive(IntPtr handle, IntPtr buffer, int bufferLen, int unknown);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceStartSession(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceStopSession(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMRestoreModeDeviceCreate(uint unknown0, int connection_id, uint unknown1);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
public extern static int AMRestoreRegisterForDeviceNotifications(
|
|
DeviceRestoreNotificationCallback dfu_connect,
|
|
DeviceRestoreNotificationCallback recovery_connect,
|
|
DeviceRestoreNotificationCallback dfu_disconnect,
|
|
DeviceRestoreNotificationCallback recovery_disconnect,
|
|
uint unknown0,
|
|
IntPtr user_info);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceUninstallApplication(
|
|
IntPtr/*AppleMobileDeviceConnection*/ device,
|
|
IntPtr/*CFString*/ ApplicationIdentifier,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceSecureUninstallApplication(
|
|
IntPtr serviceConnection,
|
|
IntPtr/*AppleMobileDeviceConnection*/ DeviceIfConnIsNull,
|
|
IntPtr/*CFString*/ ApplicationIdentifer,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceSecureTransferPath(
|
|
IntPtr serviceConnection,
|
|
IntPtr/*AppleMobileDeviceConnection*/ DeviceIfConnIsNull,
|
|
IntPtr/*CFURL*/ UrlPath,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceSecureInstallApplication(
|
|
IntPtr serviceConnection,
|
|
IntPtr/*AppleMobileDeviceConnection*/ DeviceIfConnIsNull,
|
|
IntPtr/*CFURL*/ UrlPath,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceTransferApplication(
|
|
IntPtr/*AppleMobileDeviceConnection*/ device,
|
|
IntPtr/*CFString*/ InPackagePath,
|
|
IntPtr UnknownButUnused,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceSecureUpgradeApplication(
|
|
IntPtr ServiceConnection,
|
|
IntPtr/*AppleMobileDeviceConnection*/ DeviceIfConnIsNull,
|
|
IntPtr/*CFURL*/ UrlPath,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceInstallApplication(
|
|
IntPtr/*AppleMobileDeviceConnection*/ device,
|
|
IntPtr/*CFString*/ FilePath,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
// the unknown goes into the 4th dword in the connection struct. if non-zero, winsock send() won't get called in AMDServiceConnectionSend AFAIK
|
|
// the only option is "CloseOnInvalidate" (CFBoolean type, defaults to false)
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static IntPtr AMDServiceConnectionCreate(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr UnknownTypically0, IntPtr OptionsDictionary);
|
|
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMSBeginSync(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr OuterIn8, IntPtr OuterIn12, IntPtr OuterIn16);
|
|
}
|
|
#endregion
|
|
|
|
#region AFC Operations
|
|
|
|
public int DirectoryRead(TypedPtr<AFCCommConnection> conn, IntPtr dir, ref string buffer)
|
|
{
|
|
int ret;
|
|
|
|
IntPtr ptr = IntPtr.Zero;
|
|
ret = AFC.DirectoryRead((IntPtr)conn, dir, ref ptr);
|
|
if ((ret == 0) && (ptr != IntPtr.Zero))
|
|
{
|
|
buffer = Marshal.PtrToStringAnsi(ptr);
|
|
}
|
|
else
|
|
{
|
|
buffer = null;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public class AFC
|
|
{
|
|
public static int ConnectionClose(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFCConnectionClose((IntPtr)conn);
|
|
}
|
|
|
|
public static int ConnectionInvalidate(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFCConnectionInvalidate((IntPtr)conn);
|
|
}
|
|
|
|
public static int ConnectionIsValid(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFCConnectionIsValid((IntPtr)conn);
|
|
}
|
|
|
|
public static int ConnectionOpen(IntPtr handle, uint io_timeout, out TypedPtr<AFCCommConnection> OutConn)
|
|
{
|
|
IntPtr Conn;
|
|
int Result = AFCConnectionOpen(handle, io_timeout, out Conn);
|
|
OutConn = Conn;
|
|
return Result;
|
|
}
|
|
|
|
public static int DeviceInfoOpen(IntPtr handle, ref IntPtr dict)
|
|
{
|
|
return AFCDeviceInfoOpen(handle, ref dict);
|
|
}
|
|
|
|
public static int DirectoryClose(TypedPtr<AFCCommConnection> conn, IntPtr dir)
|
|
{
|
|
return AFCDirectoryClose((IntPtr)conn, dir);
|
|
}
|
|
|
|
public static int DirectoryCreate(TypedPtr<AFCCommConnection> conn, string path)
|
|
{
|
|
return AFCDirectoryCreate((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path));
|
|
}
|
|
|
|
public static int DirectoryOpen(TypedPtr<AFCCommConnection> conn, string path, ref IntPtr dir)
|
|
{
|
|
return AFCDirectoryOpen((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path), ref dir);
|
|
}
|
|
|
|
public static int DirectoryRead(TypedPtr<AFCCommConnection> conn, IntPtr dir, ref IntPtr dirent)
|
|
{
|
|
return AFCDirectoryRead((IntPtr)conn, dir, ref dirent);
|
|
}
|
|
|
|
public static int FileInfoOpen(TypedPtr<AFCCommConnection> conn, string path, out TypedPtr<AFCDictionary> OutDict)
|
|
{
|
|
IntPtr UntypedDict;
|
|
int Result = AFCFileInfoOpen((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path), out UntypedDict);
|
|
OutDict = UntypedDict;
|
|
|
|
return Result;
|
|
}
|
|
|
|
public static int FileRefClose(TypedPtr<AFCCommConnection> conn, Int64 handle)
|
|
{
|
|
return AFCFileRefClose((IntPtr)conn, handle);
|
|
}
|
|
|
|
public static int FileRefOpen(TypedPtr<AFCCommConnection> conn, string path, Int64 mode, out Int64 handle)
|
|
{
|
|
return AFCFileRefOpen((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path), mode, out handle);
|
|
}
|
|
|
|
public static int FileRefRead(TypedPtr<AFCCommConnection> conn, Int64 handle, byte[] buffer, ref uint len)
|
|
{
|
|
return AFCFileRefRead((IntPtr)conn, handle, buffer, ref len);
|
|
}
|
|
|
|
public static int FileRefSetFileSize(TypedPtr<AFCCommConnection> conn, Int64 handle, uint size)
|
|
{
|
|
return AFCFileRefSetFileSize((IntPtr)conn, handle, size);
|
|
}
|
|
|
|
public static int FileRefSeek(TypedPtr<AFCCommConnection> conn, Int64 handle, Int64 pos, Int64 origin)
|
|
{
|
|
return AFCFileRefSeek((IntPtr)conn, handle, pos, origin);
|
|
}
|
|
|
|
public static int FileRefTell(TypedPtr<AFCCommConnection> conn, Int64 handle, ref uint position)
|
|
{
|
|
return AFCFileRefTell((IntPtr)conn, handle, ref position);
|
|
}
|
|
|
|
public static int FileRefWrite(TypedPtr<AFCCommConnection> conn, Int64 handle, byte[] buffer, uint len)
|
|
{
|
|
return AFCFileRefWrite((IntPtr)conn, handle, buffer, len);
|
|
}
|
|
|
|
public static int FlushData(TypedPtr<AFCCommConnection> conn, Int64 handle)
|
|
{
|
|
return AFCFlushData((IntPtr)conn, handle);
|
|
}
|
|
|
|
public static int KeyValueClose(TypedPtr<AFCDictionary> dict)
|
|
{
|
|
return AFCKeyValueClose((IntPtr)dict);
|
|
}
|
|
|
|
public static int KeyValueRead(TypedPtr<AFCDictionary> dict, out IntPtr key, out IntPtr val)
|
|
{
|
|
return AFCKeyValueRead((IntPtr)dict, out key, out val);
|
|
}
|
|
|
|
public static int RemovePath(TypedPtr<AFCCommConnection> conn, string path)
|
|
{
|
|
return AFCRemovePath((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path));
|
|
}
|
|
|
|
public static int RenamePath(TypedPtr<AFCCommConnection> conn, string OldPath, string NewPath)
|
|
{
|
|
return AFCRenamePath((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(OldPath), MobileDevice.StringToFileSystemRepresentation(NewPath));
|
|
}
|
|
public static int USBConnectByPort(int DeviceID, short iPort, ref IntPtr outHandle)
|
|
{
|
|
return USBMuxConnectByPort(DeviceID, iPort, ref outHandle);
|
|
}
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCConnectionClose(IntPtr/*AFCCommConnection*/ conn);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCConnectionInvalidate(IntPtr/*AFCCommConnection*/ conn);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCConnectionIsValid(IntPtr/*AFCCommConnection*/ conn);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCConnectionOpen(IntPtr handle, uint io_timeout, out IntPtr/*AFCCommConnection*/ conn);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCDeviceInfoOpen(IntPtr handle, ref IntPtr dict);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCDirectoryClose(IntPtr/*AFCCommConnection*/ conn, IntPtr dir);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCDirectoryCreate(IntPtr/*AFCCommConnection*/ conn, byte[] path);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCDirectoryOpen(IntPtr/*AFCCommConnection*/ conn, byte[] path, ref IntPtr dir);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCDirectoryRead(IntPtr/*AFCCommConnection*/ conn, IntPtr dir, ref IntPtr dirent);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileInfoOpen(IntPtr/*AFCCommConnection*/ conn, byte[] path, out IntPtr OutDict);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefClose(IntPtr/*AFCCommConnection*/ conn, Int64 handle);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefOpen(IntPtr/*AFCCommConnection*/ conn, byte[] path, Int64 mode, out Int64 handle);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefRead(IntPtr/*AFCCommConnection*/ conn, Int64 handle, byte[] buffer, ref uint len);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefSeek(IntPtr/*AFCCommConnection*/ conn, Int64 handle, Int64 pos, Int64 origin);
|
|
|
|
// FIXME - not working, arguments?
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
public extern static int AFCFileRefSetFileSize(IntPtr/*AFCCommConnection*/ conn, Int64 handle, uint size);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefTell(IntPtr/*AFCCommConnection*/ conn, Int64 handle, ref uint position);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefWrite(IntPtr/*AFCCommConnection*/ conn, Int64 handle, byte[] buffer, uint len);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFlushData(IntPtr/*AFCCommConnection*/ conn, Int64 handle);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCKeyValueClose(IntPtr dict);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCKeyValueRead(IntPtr dict, out IntPtr key, out IntPtr val);
|
|
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCRemovePath(IntPtr/*AFCCommConnection*/ conn, byte[] path);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCRenamePath(IntPtr/*AFCCommConnection*/ conn, byte[] old_path, byte[] new_path);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int USBMuxConnectByPort(int connectionID, short iPhone_port_network_byte_order, ref IntPtr outHandle);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
internal class MobileDeviceWiniTunes11 : MobileDeviceImpl
|
|
{
|
|
// static readonly int ForceStaticInit = 42;
|
|
const string DLLName = "iTunesMobileDevice.dll";
|
|
|
|
static MobileDeviceWiniTunes11()
|
|
{
|
|
List<string> PathBits = new List<string>();
|
|
|
|
// Try to add the paths from the registry (they aren't always available on newer iTunes installs though)
|
|
object RegistryDllPath = Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Apple Inc.\Apple Mobile Device Support\Shared", "iTunesMobileDeviceDLL", DLLName);
|
|
if (RegistryDllPath != null)
|
|
{
|
|
FileInfo iTunesMobileDeviceFile = new FileInfo(RegistryDllPath.ToString());
|
|
|
|
if (iTunesMobileDeviceFile.Exists)
|
|
{
|
|
PathBits.Add(iTunesMobileDeviceFile.DirectoryName);
|
|
}
|
|
}
|
|
|
|
object RegistrySupportDir = Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Apple Inc.\Apple Application Support", "InstallDir", Environment.CurrentDirectory);
|
|
if (RegistrySupportDir != null)
|
|
{
|
|
DirectoryInfo ApplicationSupportDirectory = new DirectoryInfo(RegistrySupportDir.ToString());
|
|
|
|
if (ApplicationSupportDirectory.Exists)
|
|
{
|
|
PathBits.Add(ApplicationSupportDirectory.FullName);
|
|
}
|
|
}
|
|
|
|
// Add some guesses as well
|
|
DirectoryInfo AppleMobileDeviceSupport = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.CommonProgramFiles) + @"\Apple\Mobile Device Support");
|
|
if (AppleMobileDeviceSupport.Exists)
|
|
{
|
|
PathBits.Add(AppleMobileDeviceSupport.FullName);
|
|
}
|
|
|
|
DirectoryInfo AppleMobileDeviceSupportX86 = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.CommonProgramFilesX86) + @"\Apple\Mobile Device Support");
|
|
if ((AppleMobileDeviceSupport != AppleMobileDeviceSupportX86) && (AppleMobileDeviceSupportX86.Exists))
|
|
{
|
|
PathBits.Add(AppleMobileDeviceSupportX86.FullName);
|
|
}
|
|
|
|
// add the rest of the path
|
|
PathBits.Add(Environment.GetEnvironmentVariable("Path"));
|
|
|
|
// Set the path from all the individual bits
|
|
Environment.SetEnvironmentVariable("Path", string.Join(";", PathBits));
|
|
}
|
|
|
|
public int NotificationSubscribe(DeviceNotificationCallback DeviceCallbackHandle)
|
|
{
|
|
return AMDeviceMethods.NotificationSubscribe(DeviceCallbackHandle);
|
|
}
|
|
|
|
public IntPtr CopyDeviceIdentifier(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.CopyDeviceIdentifier(device);
|
|
}
|
|
|
|
public int Connect(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.Connect(device);
|
|
}
|
|
|
|
public IntPtr CopyValue(TypedPtr<AppleMobileDeviceConnection> device, uint unknown, TypedPtr<CFString> cfstring)
|
|
{
|
|
return AMDeviceMethods.CopyValue(device, unknown, cfstring);
|
|
}
|
|
|
|
public int Disconnect(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.Disconnect(device);
|
|
}
|
|
|
|
public int GetConnectionID(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.GetConnectionID(device);
|
|
}
|
|
|
|
public int IsPaired(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.IsPaired(device);
|
|
}
|
|
|
|
public int Pair(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.Pair(device);
|
|
}
|
|
|
|
public int Unpair(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.Unpair(device);
|
|
}
|
|
|
|
public int ValidatePairing(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.ValidatePairing(device);
|
|
}
|
|
|
|
public int LookupApplications(TypedPtr<AppleMobileDeviceConnection> device, IntPtr options, out Dictionary<string, object> AppBundles)
|
|
{
|
|
int Result = AMDeviceMethods.LookupApplications(device, options, out AppBundles);
|
|
return Result;
|
|
}
|
|
|
|
public int StartSession(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.StartSession((IntPtr)device);
|
|
}
|
|
|
|
public int StopSession(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.StopSession((IntPtr)device);
|
|
}
|
|
|
|
public int StartHouseArrestService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> bundleName, IntPtr unknown1, ref IntPtr handle, int unknown2)
|
|
{
|
|
return AMDeviceMethods.StartHouseArrestService((IntPtr)device, (IntPtr)bundleName, unknown1, ref handle, unknown2);
|
|
}
|
|
|
|
public int CreateHouseArrestService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> bundleName, IntPtr unknown1, out TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AMDeviceMethods.CreateHouseArrestService((IntPtr)device, (IntPtr)bundleName, unknown1, out conn);
|
|
}
|
|
|
|
public int StartService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> serviceName, ref IntPtr handle, IntPtr unknown)
|
|
{
|
|
return AMDeviceMethods.StartService((IntPtr)device, (IntPtr)serviceName, ref handle, unknown);
|
|
}
|
|
|
|
public int SecureStartService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> serviceName, int flagsPassInZero, ref IntPtr handle)
|
|
{
|
|
return AMDeviceMethods.SecureStartService((IntPtr)device, (IntPtr)serviceName, flagsPassInZero, ref handle);
|
|
}
|
|
|
|
public string ServiceConnectionReceive(IntPtr handle)
|
|
{
|
|
return AMDeviceMethods.ServiceConnectionReceive(handle);
|
|
}
|
|
|
|
[DllImport("ws2_32.dll")]
|
|
public static extern int send(IntPtr Socket, IntPtr buff, int len, int flags);
|
|
public int SocketSend(IntPtr fd, IntPtr buf, int count)
|
|
{
|
|
return (int)send(fd, buf, count, 0);
|
|
}
|
|
|
|
[DllImport("ws2_32.dll")]
|
|
public static extern void closesocket(IntPtr fd);
|
|
public void SocketClose(IntPtr fd)
|
|
{
|
|
closesocket(fd);
|
|
}
|
|
|
|
public int RestoreRegisterForDeviceNotifications(
|
|
DeviceRestoreNotificationCallback dfu_connect,
|
|
DeviceRestoreNotificationCallback recovery_connect,
|
|
DeviceRestoreNotificationCallback dfu_disconnect,
|
|
DeviceRestoreNotificationCallback recovery_disconnect,
|
|
uint unknown0,
|
|
IntPtr user_info)
|
|
{
|
|
return AMDeviceMethods.AMRestoreRegisterForDeviceNotifications(dfu_connect, recovery_connect, dfu_disconnect, recovery_disconnect, unknown0, user_info);
|
|
}
|
|
|
|
public int SecureUninstallApplication(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFString> ApplicationIdentifer,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceMethods.SecureUninstallApplication(serviceConnection, DeviceIfConnIsNull, ApplicationIdentifer, ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public int SecureTransferPath(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceMethods.SecureTransferPath(serviceConnection, DeviceIfConnIsNull, UrlPath, ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public int SecureInstallApplication(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceMethods.SecureInstallApplication(serviceConnection, DeviceIfConnIsNull, UrlPath, ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public int SecureUpgradeApplication(
|
|
IntPtr ServiceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceMethods.SecureUpgradeApplication(ServiceConnection, DeviceIfConnIsNull, UrlPath, ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public int ConnectionClose(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFC.ConnectionClose(conn);
|
|
}
|
|
|
|
public int ConnectionInvalidate(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFC.ConnectionInvalidate(conn);
|
|
}
|
|
|
|
public int ConnectionIsValid(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFC.ConnectionIsValid(conn);
|
|
}
|
|
|
|
public int ConnectionOpen(IntPtr handle, uint io_timeout, out TypedPtr<AFCCommConnection> OutConn)
|
|
{
|
|
return AFC.ConnectionOpen(handle, io_timeout, out OutConn);
|
|
}
|
|
|
|
public int DeviceInfoOpen(IntPtr handle, ref IntPtr dict)
|
|
{
|
|
return AFC.DeviceInfoOpen(handle, ref dict);
|
|
}
|
|
|
|
public int DirectoryClose(TypedPtr<AFCCommConnection> conn, IntPtr dir)
|
|
{
|
|
return AFC.DirectoryClose(conn, dir);
|
|
}
|
|
|
|
public int DirectoryCreate(TypedPtr<AFCCommConnection> conn, string path)
|
|
{
|
|
return AFC.DirectoryCreate(conn, path);
|
|
}
|
|
|
|
public int DirectoryOpen(TypedPtr<AFCCommConnection> conn, string path, ref IntPtr dir)
|
|
{
|
|
return AFC.DirectoryOpen(conn, path, ref dir);
|
|
}
|
|
|
|
public int DirectoryRead(TypedPtr<AFCCommConnection> conn, IntPtr dir, ref IntPtr dirent)
|
|
{
|
|
return AFC.DirectoryRead(conn, dir, ref dirent);
|
|
}
|
|
|
|
public int FileInfoOpen(TypedPtr<AFCCommConnection> conn, string path, out TypedPtr<AFCDictionary> OutDict)
|
|
{
|
|
return AFC.FileInfoOpen(conn, path, out OutDict);
|
|
}
|
|
|
|
public int FileRefClose(TypedPtr<AFCCommConnection> conn, Int64 handle)
|
|
{
|
|
return AFC.FileRefClose(conn, handle);
|
|
}
|
|
|
|
public int FileRefOpen(TypedPtr<AFCCommConnection> conn, string path, Int64 mode, out Int64 handle)
|
|
{
|
|
return AFC.FileRefOpen(conn, path, mode, out handle);
|
|
}
|
|
|
|
public int FileRefRead(TypedPtr<AFCCommConnection> conn, Int64 handle, byte[] buffer, ref uint len)
|
|
{
|
|
return AFC.FileRefRead(conn, handle, buffer, ref len);
|
|
}
|
|
|
|
public int FileRefSeek(TypedPtr<AFCCommConnection> conn, Int64 handle, Int64 pos, Int64 origin)
|
|
{
|
|
return AFC.FileRefSeek(conn, handle, pos, origin);
|
|
}
|
|
|
|
public int FileRefSetFileSize(TypedPtr<AFCCommConnection> conn, Int64 handle, uint size)
|
|
{
|
|
return AFC.FileRefSetFileSize(conn, handle, size);
|
|
}
|
|
|
|
public int FileRefTell(TypedPtr<AFCCommConnection> conn, Int64 handle, ref uint position)
|
|
{
|
|
return AFC.FileRefTell(conn, handle, ref position);
|
|
}
|
|
|
|
public int FileRefWrite(TypedPtr<AFCCommConnection> conn, Int64 handle, byte[] buffer, uint len)
|
|
{
|
|
return AFC.FileRefWrite(conn, handle, buffer, len);
|
|
}
|
|
|
|
public int FlushData(TypedPtr<AFCCommConnection> conn, Int64 handle)
|
|
{
|
|
return AFC.FlushData(conn, handle);
|
|
}
|
|
|
|
public int KeyValueClose(TypedPtr<AFCDictionary> dict)
|
|
{
|
|
return AFC.KeyValueClose(dict);
|
|
}
|
|
|
|
public int KeyValueRead(TypedPtr<AFCDictionary> dict, out IntPtr key, out IntPtr val)
|
|
{
|
|
return AFC.KeyValueRead(dict, out key, out val);
|
|
}
|
|
|
|
public int RemovePath(TypedPtr<AFCCommConnection> conn, string path)
|
|
{
|
|
return AFC.RemovePath(conn, path);
|
|
}
|
|
|
|
public int RenamePath(TypedPtr<AFCCommConnection> conn, string OldPath, string NewPath)
|
|
{
|
|
return AFC.RenamePath(conn, OldPath, NewPath);
|
|
}
|
|
|
|
public int USBMuxConnectByPort(int DeviceID, short iPort, ref IntPtr outHandle)
|
|
{
|
|
return AFC.USBConnectByPort(DeviceID, iPort, ref outHandle);
|
|
}
|
|
|
|
#region Application Methods
|
|
public class AMDeviceMethods
|
|
{
|
|
// Need to have the path manipulation code in static MobileDevice() to run
|
|
// static int ForceMobileDeviceConstructorToRun;
|
|
static AMDeviceMethods()
|
|
{
|
|
// ForceMobileDeviceConstructorToRun = ForceStaticInit;
|
|
}
|
|
|
|
public static IntPtr CopyDeviceIdentifier(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceCopyDeviceIdentifier((IntPtr)device);
|
|
}
|
|
|
|
public static int Connect(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceConnect((IntPtr)device);
|
|
}
|
|
|
|
public static IntPtr CopyValue(TypedPtr<AppleMobileDeviceConnection> device, uint unknown, TypedPtr<CFString> cfstring)
|
|
{
|
|
return AMDeviceCopyValue((IntPtr)device, unknown, (IntPtr)cfstring);
|
|
}
|
|
|
|
public static int Disconnect(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceDisconnect((IntPtr)device);
|
|
}
|
|
|
|
public static int GetConnectionID(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceGetConnectionID((IntPtr)device);
|
|
}
|
|
|
|
public static int IsPaired(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceIsPaired((IntPtr)device);
|
|
}
|
|
|
|
public static int Pair(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDevicePair((IntPtr)device);
|
|
}
|
|
|
|
public static int Unpair(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceUnpair((IntPtr)device);
|
|
}
|
|
|
|
public static int ValidatePairing(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceValidatePairing((IntPtr)device);
|
|
}
|
|
|
|
public static int LookupApplications(TypedPtr<AppleMobileDeviceConnection> device, IntPtr options, out Dictionary<string, object> AppBundles)
|
|
{
|
|
IntPtr UntypedDict = IntPtr.Zero;
|
|
int Result = AMDeviceLookupApplications((IntPtr)device, options, ref UntypedDict);
|
|
|
|
AppBundles = MobileDevice.ConvertCFDictionaryToDictionaryString(new TypedPtr<CFDictionary>(UntypedDict));
|
|
|
|
return Result;
|
|
}
|
|
|
|
public static int StartSession(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceStartSession((IntPtr)device);
|
|
}
|
|
|
|
public static int StopSession(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceStopSession((IntPtr)device);
|
|
}
|
|
|
|
public static int StartHouseArrestService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> bundleName, IntPtr unknown1, ref IntPtr handle, int unknown2)
|
|
{
|
|
return AMDeviceStartHouseArrestService((IntPtr)device, (IntPtr)bundleName, unknown1, ref handle, unknown2);
|
|
}
|
|
|
|
public static int CreateHouseArrestService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> bundleName, IntPtr unknown1, out TypedPtr<AFCCommConnection> OutConn)
|
|
{
|
|
IntPtr Conn;
|
|
int Result = AMDeviceCreateHouseArrestService((IntPtr)device, (IntPtr)bundleName, unknown1, out Conn);
|
|
OutConn = Conn;
|
|
return Result;
|
|
}
|
|
|
|
public static int StartService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> serviceName, ref IntPtr handle, IntPtr unknown)
|
|
{
|
|
return AMDeviceStartService((IntPtr)device, (IntPtr)serviceName, ref handle, unknown);
|
|
}
|
|
|
|
public static int SecureStartService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> serviceName, int flagsPassInZero, ref IntPtr handle)
|
|
{
|
|
return AMDeviceSecureStartService((IntPtr)device, (IntPtr)serviceName, flagsPassInZero, ref handle);
|
|
}
|
|
|
|
|
|
public static string ServiceConnectionReceive(IntPtr handle)
|
|
{
|
|
byte[] Buffer = new byte[1024];
|
|
|
|
IntPtr UnmanagedPointer = Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0);
|
|
int Ret = AMDServiceConnectionReceive(handle, UnmanagedPointer, 1023, 0);
|
|
Buffer[Ret] = 0;
|
|
int Start = 0;
|
|
string Result = "";
|
|
int I;
|
|
for (I = 0; I < Ret; I++)
|
|
{
|
|
if (Buffer[I] == 0)
|
|
{
|
|
Result += System.Text.Encoding.UTF8.GetString(Buffer, Start, I - Start);
|
|
Start = I + 1;
|
|
}
|
|
}
|
|
if (I > Start)
|
|
{
|
|
Result += System.Text.Encoding.UTF8.GetString(Buffer, Start, I - Start);
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
public static int UninstallApplication(
|
|
TypedPtr<AppleMobileDeviceConnection> device,
|
|
TypedPtr<CFString> ApplicationIdentifier,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceUninstallApplication((IntPtr)device, (IntPtr)ApplicationIdentifier, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int SecureUninstallApplication(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFString> ApplicationIdentifer,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceSecureUninstallApplication(serviceConnection, (IntPtr)DeviceIfConnIsNull, (IntPtr)ApplicationIdentifer, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int SecureTransferPath(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceSecureTransferPath(serviceConnection, (IntPtr)DeviceIfConnIsNull, (IntPtr)UrlPath, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int SecureInstallApplication(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceSecureInstallApplication(serviceConnection, (IntPtr)DeviceIfConnIsNull, (IntPtr)UrlPath, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int TransferApplication(
|
|
TypedPtr<AppleMobileDeviceConnection> device,
|
|
TypedPtr<CFString> InPackagePath,
|
|
IntPtr UnknownButUnused,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceTransferApplication((IntPtr)device, (IntPtr)InPackagePath, UnknownButUnused, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int SecureUpgradeApplication(
|
|
IntPtr ServiceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceSecureUpgradeApplication(ServiceConnection, (IntPtr)DeviceIfConnIsNull, (IntPtr)UrlPath, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int InstallApplication(
|
|
TypedPtr<AppleMobileDeviceConnection> device,
|
|
TypedPtr<CFString> FilePath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceInstallApplication((IntPtr)device, (IntPtr)FilePath, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int NotificationSubscribe(DeviceNotificationCallback DeviceCallbackHandle)
|
|
{
|
|
IntPtr notification;
|
|
return AMDeviceNotificationSubscribe(DeviceCallbackHandle, 0, 0, 0, out notification);
|
|
}
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static IntPtr AMDeviceCopyDeviceIdentifier(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceConnect(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static IntPtr AMDeviceCopyValue(IntPtr/*AppleMobileDeviceConnection*/ device, uint unknown, IntPtr/*CFString*/ cfstring);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceDisconnect(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceGetConnectionID(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceIsPaired(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDevicePair(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceUnpair(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceValidatePairing(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceLookupApplications(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr options, ref IntPtr appBundles);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceNotificationSubscribe(DeviceNotificationCallback callback, uint unused1, uint unused2, uint unused3, out IntPtr am_device_notification_ptr);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceStartHouseArrestService(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr/*CFString*/ bundleName, IntPtr unknown1, ref IntPtr handle, int unknown2);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceCreateHouseArrestService(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr/*CFString*/ bundleName, IntPtr unknown1, out IntPtr conn);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceStartService(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr/*CFString*/ serviceName, ref IntPtr handle, IntPtr unknown);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceSecureStartService(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr/*CFString*/ serviceName, int flagsPassInZero, ref IntPtr handle);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDServiceConnectionReceive(IntPtr handle, IntPtr buffer, int bufferLen, int unknown);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceStartSession(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceStopSession(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMRestoreModeDeviceCreate(uint unknown0, int connection_id, uint unknown1);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
public extern static int AMRestoreRegisterForDeviceNotifications(
|
|
DeviceRestoreNotificationCallback dfu_connect,
|
|
DeviceRestoreNotificationCallback recovery_connect,
|
|
DeviceRestoreNotificationCallback dfu_disconnect,
|
|
DeviceRestoreNotificationCallback recovery_disconnect,
|
|
uint unknown0,
|
|
IntPtr user_info);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceUninstallApplication(
|
|
IntPtr/*AppleMobileDeviceConnection*/ device,
|
|
IntPtr/*CFString*/ ApplicationIdentifier,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceSecureUninstallApplication(
|
|
IntPtr serviceConnection,
|
|
IntPtr/*AppleMobileDeviceConnection*/ DeviceIfConnIsNull,
|
|
IntPtr/*CFString*/ ApplicationIdentifer,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceSecureTransferPath(
|
|
IntPtr serviceConnection,
|
|
IntPtr/*AppleMobileDeviceConnection*/ DeviceIfConnIsNull,
|
|
IntPtr/*CFURL*/ UrlPath,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceSecureInstallApplication(
|
|
IntPtr serviceConnection,
|
|
IntPtr/*AppleMobileDeviceConnection*/ DeviceIfConnIsNull,
|
|
IntPtr/*CFURL*/ UrlPath,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceTransferApplication(
|
|
IntPtr/*AppleMobileDeviceConnection*/ device,
|
|
IntPtr/*CFString*/ InPackagePath,
|
|
IntPtr UnknownButUnused,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceSecureUpgradeApplication(
|
|
IntPtr ServiceConnection,
|
|
IntPtr/*AppleMobileDeviceConnection*/ DeviceIfConnIsNull,
|
|
IntPtr/*CFURL*/ UrlPath,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceInstallApplication(
|
|
IntPtr/*AppleMobileDeviceConnection*/ device,
|
|
IntPtr/*CFString*/ FilePath,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
// the unknown goes into the 4th dword in the connection struct. if non-zero, winsock send() won't get called in AMDServiceConnectionSend AFAIK
|
|
// the only option is "CloseOnInvalidate" (CFBoolean type, defaults to false)
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static IntPtr AMDServiceConnectionCreate(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr UnknownTypically0, IntPtr OptionsDictionary);
|
|
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMSBeginSync(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr OuterIn8, IntPtr OuterIn12, IntPtr OuterIn16);
|
|
}
|
|
#endregion
|
|
|
|
#region AFC Operations
|
|
|
|
public int DirectoryRead(TypedPtr<AFCCommConnection> conn, IntPtr dir, ref string buffer)
|
|
{
|
|
int ret;
|
|
|
|
IntPtr ptr = IntPtr.Zero;
|
|
ret = AFC.DirectoryRead((IntPtr)conn, dir, ref ptr);
|
|
if ((ret == 0) && (ptr != IntPtr.Zero))
|
|
{
|
|
buffer = Marshal.PtrToStringAnsi(ptr);
|
|
}
|
|
else
|
|
{
|
|
buffer = null;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public class AFC
|
|
{
|
|
public static int ConnectionClose(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFCConnectionClose((IntPtr)conn);
|
|
}
|
|
|
|
public static int ConnectionInvalidate(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFCConnectionInvalidate((IntPtr)conn);
|
|
}
|
|
|
|
public static int ConnectionIsValid(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFCConnectionIsValid((IntPtr)conn);
|
|
}
|
|
|
|
public static int ConnectionOpen(IntPtr handle, uint io_timeout, out TypedPtr<AFCCommConnection> OutConn)
|
|
{
|
|
IntPtr Conn;
|
|
int Result = AFCConnectionOpen(handle, io_timeout, out Conn);
|
|
OutConn = Conn;
|
|
return Result;
|
|
}
|
|
|
|
public static int DeviceInfoOpen(IntPtr handle, ref IntPtr dict)
|
|
{
|
|
return AFCDeviceInfoOpen(handle, ref dict);
|
|
}
|
|
|
|
public static int DirectoryClose(TypedPtr<AFCCommConnection> conn, IntPtr dir)
|
|
{
|
|
return AFCDirectoryClose((IntPtr)conn, dir);
|
|
}
|
|
|
|
public static int DirectoryCreate(TypedPtr<AFCCommConnection> conn, string path)
|
|
{
|
|
return AFCDirectoryCreate((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path));
|
|
}
|
|
|
|
public static int DirectoryOpen(TypedPtr<AFCCommConnection> conn, string path, ref IntPtr dir)
|
|
{
|
|
return AFCDirectoryOpen((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path), ref dir);
|
|
}
|
|
|
|
public static int DirectoryRead(TypedPtr<AFCCommConnection> conn, IntPtr dir, ref IntPtr dirent)
|
|
{
|
|
return AFCDirectoryRead((IntPtr)conn, dir, ref dirent);
|
|
}
|
|
|
|
public static int FileInfoOpen(TypedPtr<AFCCommConnection> conn, string path, out TypedPtr<AFCDictionary> OutDict)
|
|
{
|
|
IntPtr UntypedDict;
|
|
int Result = AFCFileInfoOpen((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path), out UntypedDict);
|
|
OutDict = UntypedDict;
|
|
|
|
return Result;
|
|
}
|
|
|
|
public static int FileRefClose(TypedPtr<AFCCommConnection> conn, Int64 handle)
|
|
{
|
|
return AFCFileRefClose((IntPtr)conn, handle);
|
|
}
|
|
|
|
public static int FileRefOpen(TypedPtr<AFCCommConnection> conn, string path, Int64 mode, out Int64 handle)
|
|
{
|
|
return AFCFileRefOpen((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path), mode, out handle);
|
|
}
|
|
|
|
public static int FileRefRead(TypedPtr<AFCCommConnection> conn, Int64 handle, byte[] buffer, ref uint len)
|
|
{
|
|
return AFCFileRefRead((IntPtr)conn, handle, buffer, ref len);
|
|
}
|
|
|
|
public static int FileRefSetFileSize(TypedPtr<AFCCommConnection> conn, Int64 handle, uint size)
|
|
{
|
|
return AFCFileRefSetFileSize((IntPtr)conn, handle, size);
|
|
}
|
|
|
|
public static int FileRefSeek(TypedPtr<AFCCommConnection> conn, Int64 handle, Int64 pos, Int64 origin)
|
|
{
|
|
return AFCFileRefSeek((IntPtr)conn, handle, pos, origin);
|
|
}
|
|
|
|
public static int FileRefTell(TypedPtr<AFCCommConnection> conn, Int64 handle, ref uint position)
|
|
{
|
|
return AFCFileRefTell((IntPtr)conn, handle, ref position);
|
|
}
|
|
|
|
public static int FileRefWrite(TypedPtr<AFCCommConnection> conn, Int64 handle, byte[] buffer, uint len)
|
|
{
|
|
return AFCFileRefWrite((IntPtr)conn, handle, buffer, len);
|
|
}
|
|
|
|
public static int FlushData(TypedPtr<AFCCommConnection> conn, Int64 handle)
|
|
{
|
|
return AFCFlushData((IntPtr)conn, handle);
|
|
}
|
|
|
|
public static int KeyValueClose(TypedPtr<AFCDictionary> dict)
|
|
{
|
|
return AFCKeyValueClose((IntPtr)dict);
|
|
}
|
|
|
|
public static int KeyValueRead(TypedPtr<AFCDictionary> dict, out IntPtr key, out IntPtr val)
|
|
{
|
|
return AFCKeyValueRead((IntPtr)dict, out key, out val);
|
|
}
|
|
|
|
public static int RemovePath(TypedPtr<AFCCommConnection> conn, string path)
|
|
{
|
|
return AFCRemovePath((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path));
|
|
}
|
|
|
|
public static int RenamePath(TypedPtr<AFCCommConnection> conn, string OldPath, string NewPath)
|
|
{
|
|
return AFCRenamePath((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(OldPath), MobileDevice.StringToFileSystemRepresentation(NewPath));
|
|
}
|
|
|
|
public static int USBConnectByPort(int DeviceID, short iPort, ref IntPtr outHandle)
|
|
{
|
|
return USBMuxConnectByPort(DeviceID, iPort, ref outHandle);
|
|
}
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCConnectionClose(IntPtr/*AFCCommConnection*/ conn);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCConnectionInvalidate(IntPtr/*AFCCommConnection*/ conn);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCConnectionIsValid(IntPtr/*AFCCommConnection*/ conn);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCConnectionOpen(IntPtr handle, uint io_timeout, out IntPtr/*AFCCommConnection*/ conn);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCDeviceInfoOpen(IntPtr handle, ref IntPtr dict);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCDirectoryClose(IntPtr/*AFCCommConnection*/ conn, IntPtr dir);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCDirectoryCreate(IntPtr/*AFCCommConnection*/ conn, byte[] path);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCDirectoryOpen(IntPtr/*AFCCommConnection*/ conn, byte[] path, ref IntPtr dir);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCDirectoryRead(IntPtr/*AFCCommConnection*/ conn, IntPtr dir, ref IntPtr dirent);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileInfoOpen(IntPtr/*AFCCommConnection*/ conn, byte[] path, out IntPtr OutDict);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefClose(IntPtr/*AFCCommConnection*/ conn, Int64 handle);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefOpen(IntPtr/*AFCCommConnection*/ conn, byte[] path, Int64 mode, out Int64 handle);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefRead(IntPtr/*AFCCommConnection*/ conn, Int64 handle, byte[] buffer, ref uint len);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefSeek(IntPtr/*AFCCommConnection*/ conn, Int64 handle, Int64 pos, Int64 origin);
|
|
|
|
// FIXME - not working, arguments?
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
public extern static int AFCFileRefSetFileSize(IntPtr/*AFCCommConnection*/ conn, Int64 handle, uint size);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefTell(IntPtr/*AFCCommConnection*/ conn, Int64 handle, ref uint position);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefWrite(IntPtr/*AFCCommConnection*/ conn, Int64 handle, byte[] buffer, uint len);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFlushData(IntPtr/*AFCCommConnection*/ conn, Int64 handle);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCKeyValueClose(IntPtr dict);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCKeyValueRead(IntPtr dict, out IntPtr key, out IntPtr val);
|
|
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCRemovePath(IntPtr/*AFCCommConnection*/ conn, byte[] path);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCRenamePath(IntPtr/*AFCCommConnection*/ conn, byte[] old_path, byte[] new_path);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int USBMuxConnectByPort(int connectionID, short iPhone_port_network_byte_order, ref IntPtr outHandle);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
internal class MobileDeviceWiniTunes12 : MobileDeviceImpl
|
|
{
|
|
// static readonly int ForceStaticInit = 42;
|
|
const string DLLName = @"MobileDevice.dll";
|
|
|
|
static MobileDeviceWiniTunes12()
|
|
{
|
|
List<string> PathBits = new List<string>();
|
|
|
|
// Try to add the paths from the registry (they aren't always available on newer iTunes installs though)
|
|
object RegistryDllPath = Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Apple Inc.\Apple Mobile Device Support\Shared", "MobileDeviceDLL", DLLName);
|
|
if (RegistryDllPath != null)
|
|
{
|
|
FileInfo iTunesMobileDeviceFile = new FileInfo(RegistryDllPath.ToString());
|
|
|
|
if (iTunesMobileDeviceFile.Exists)
|
|
{
|
|
PathBits.Add(iTunesMobileDeviceFile.DirectoryName);
|
|
}
|
|
}
|
|
|
|
string iTunesWindowsStoreRegistryDllPath = ITunesFinder.FindWindowsStoreITunesDLL();
|
|
if(iTunesWindowsStoreRegistryDllPath != null)
|
|
{
|
|
FileInfo iTunesMobileDeviceFile = new FileInfo(iTunesWindowsStoreRegistryDllPath);
|
|
|
|
if (iTunesMobileDeviceFile.Exists)
|
|
{
|
|
PathBits.Add(iTunesMobileDeviceFile.DirectoryName);
|
|
PathBits.Add(ITunesFinder.FindWindowsStoreITunesInstallPath() + "\\VFS\\ProgramFilesCommonX86\\Apple\\Apple Application Support");
|
|
}
|
|
}
|
|
|
|
object RegistrySupportDir = Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Apple Inc.\Apple Application Support", "InstallDir", Environment.CurrentDirectory);
|
|
if (RegistrySupportDir != null)
|
|
{
|
|
DirectoryInfo ApplicationSupportDirectory = new DirectoryInfo(RegistrySupportDir.ToString());
|
|
|
|
if (ApplicationSupportDirectory.Exists)
|
|
{
|
|
PathBits.Add(ApplicationSupportDirectory.FullName);
|
|
}
|
|
}
|
|
|
|
// Add some guesses as well
|
|
DirectoryInfo AppleMobileDeviceSupport = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.CommonProgramFiles) + @"\Apple\Mobile Device Support");
|
|
if (AppleMobileDeviceSupport.Exists)
|
|
{
|
|
PathBits.Add(AppleMobileDeviceSupport.FullName);
|
|
}
|
|
|
|
DirectoryInfo AppleMobileDeviceSupportX86 = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.CommonProgramFilesX86) + @"\Apple\Mobile Device Support");
|
|
if ((AppleMobileDeviceSupport != AppleMobileDeviceSupportX86) && (AppleMobileDeviceSupportX86.Exists))
|
|
{
|
|
PathBits.Add(AppleMobileDeviceSupportX86.FullName);
|
|
}
|
|
|
|
// add the rest of the path
|
|
PathBits.Add(Environment.GetEnvironmentVariable("Path"));
|
|
|
|
// Set the path from all the individual bits
|
|
Environment.SetEnvironmentVariable("Path", string.Join(";", PathBits));
|
|
}
|
|
|
|
public int NotificationSubscribe(DeviceNotificationCallback DeviceCallbackHandle)
|
|
{
|
|
return AMDeviceMethods.NotificationSubscribe(DeviceCallbackHandle);
|
|
}
|
|
|
|
public IntPtr CopyDeviceIdentifier(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.CopyDeviceIdentifier(device);
|
|
}
|
|
|
|
public int Connect(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.Connect(device);
|
|
}
|
|
|
|
public IntPtr CopyValue(TypedPtr<AppleMobileDeviceConnection> device, uint unknown, TypedPtr<CFString> cfstring)
|
|
{
|
|
return AMDeviceMethods.CopyValue(device, unknown, cfstring);
|
|
}
|
|
|
|
public int Disconnect(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.Disconnect(device);
|
|
}
|
|
|
|
public int GetConnectionID(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.GetConnectionID(device);
|
|
}
|
|
|
|
public int IsPaired(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.IsPaired(device);
|
|
}
|
|
|
|
public int Pair(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.Pair(device);
|
|
}
|
|
|
|
public int Unpair(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.Unpair(device);
|
|
}
|
|
|
|
public int ValidatePairing(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.ValidatePairing(device);
|
|
}
|
|
|
|
public int LookupApplications(TypedPtr<AppleMobileDeviceConnection> device, IntPtr options, out Dictionary<string, object> AppBundles)
|
|
{
|
|
int Result = AMDeviceMethods.LookupApplications(device, options, out AppBundles);
|
|
return Result;
|
|
}
|
|
|
|
public int StartSession(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.StartSession((IntPtr)device);
|
|
}
|
|
|
|
public int StopSession(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceMethods.StopSession((IntPtr)device);
|
|
}
|
|
|
|
public int StartHouseArrestService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> bundleName, IntPtr unknown1, ref IntPtr handle, int unknown2)
|
|
{
|
|
return AMDeviceMethods.StartHouseArrestService((IntPtr)device, (IntPtr)bundleName, unknown1, ref handle, unknown2);
|
|
}
|
|
|
|
public int CreateHouseArrestService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> bundleName, IntPtr unknown1, out TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AMDeviceMethods.CreateHouseArrestService((IntPtr)device, (IntPtr)bundleName, unknown1, out conn);
|
|
}
|
|
|
|
public int StartService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> serviceName, ref IntPtr handle, IntPtr unknown)
|
|
{
|
|
return AMDeviceMethods.StartService((IntPtr)device, (IntPtr)serviceName, ref handle, unknown);
|
|
}
|
|
|
|
public int SecureStartService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> serviceName, int flagsPassInZero, ref IntPtr handle)
|
|
{
|
|
return AMDeviceMethods.SecureStartService((IntPtr)device, (IntPtr)serviceName, flagsPassInZero, ref handle);
|
|
}
|
|
|
|
public string ServiceConnectionReceive(IntPtr handle)
|
|
{
|
|
return AMDeviceMethods.ServiceConnectionReceive(handle);
|
|
}
|
|
|
|
[DllImport("ws2_32.dll")]
|
|
public static extern int send(IntPtr Socket, IntPtr buff, int len, int flags);
|
|
public int SocketSend(IntPtr fd, IntPtr buf, int count)
|
|
{
|
|
return (int)send(fd, buf, count, 0);
|
|
}
|
|
|
|
[DllImport("ws2_32.dll")]
|
|
public static extern void closesocket(IntPtr fd);
|
|
public void SocketClose(IntPtr fd)
|
|
{
|
|
closesocket(fd);
|
|
}
|
|
|
|
public int RestoreRegisterForDeviceNotifications(
|
|
DeviceRestoreNotificationCallback dfu_connect,
|
|
DeviceRestoreNotificationCallback recovery_connect,
|
|
DeviceRestoreNotificationCallback dfu_disconnect,
|
|
DeviceRestoreNotificationCallback recovery_disconnect,
|
|
uint unknown0,
|
|
IntPtr user_info)
|
|
{
|
|
return AMDeviceMethods.AMRestoreRegisterForDeviceNotifications(dfu_connect, recovery_connect, dfu_disconnect, recovery_disconnect, unknown0, user_info);
|
|
}
|
|
|
|
public int SecureUninstallApplication(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFString> ApplicationIdentifer,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceMethods.SecureUninstallApplication(serviceConnection, DeviceIfConnIsNull, ApplicationIdentifer, ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public int SecureTransferPath(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceMethods.SecureTransferPath(serviceConnection, DeviceIfConnIsNull, UrlPath, ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public int SecureInstallApplication(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceMethods.SecureInstallApplication(serviceConnection, DeviceIfConnIsNull, UrlPath, ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public int SecureUpgradeApplication(
|
|
IntPtr ServiceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceMethods.SecureUpgradeApplication(ServiceConnection, DeviceIfConnIsNull, UrlPath, ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public int ConnectionClose(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFC.ConnectionClose(conn);
|
|
}
|
|
|
|
public int ConnectionInvalidate(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFC.ConnectionInvalidate(conn);
|
|
}
|
|
|
|
public int ConnectionIsValid(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFC.ConnectionIsValid(conn);
|
|
}
|
|
|
|
public int ConnectionOpen(IntPtr handle, uint io_timeout, out TypedPtr<AFCCommConnection> OutConn)
|
|
{
|
|
return AFC.ConnectionOpen(handle, io_timeout, out OutConn);
|
|
}
|
|
|
|
public int DeviceInfoOpen(IntPtr handle, ref IntPtr dict)
|
|
{
|
|
return AFC.DeviceInfoOpen(handle, ref dict);
|
|
}
|
|
|
|
public int DirectoryClose(TypedPtr<AFCCommConnection> conn, IntPtr dir)
|
|
{
|
|
return AFC.DirectoryClose(conn, dir);
|
|
}
|
|
|
|
public int DirectoryCreate(TypedPtr<AFCCommConnection> conn, string path)
|
|
{
|
|
return AFC.DirectoryCreate(conn, path);
|
|
}
|
|
|
|
public int DirectoryOpen(TypedPtr<AFCCommConnection> conn, string path, ref IntPtr dir)
|
|
{
|
|
return AFC.DirectoryOpen(conn, path, ref dir);
|
|
}
|
|
|
|
public int DirectoryRead(TypedPtr<AFCCommConnection> conn, IntPtr dir, ref IntPtr dirent)
|
|
{
|
|
return AFC.DirectoryRead(conn, dir, ref dirent);
|
|
}
|
|
|
|
public int FileInfoOpen(TypedPtr<AFCCommConnection> conn, string path, out TypedPtr<AFCDictionary> OutDict)
|
|
{
|
|
return AFC.FileInfoOpen(conn, path, out OutDict);
|
|
}
|
|
|
|
public int FileRefClose(TypedPtr<AFCCommConnection> conn, Int64 handle)
|
|
{
|
|
return AFC.FileRefClose(conn, handle);
|
|
}
|
|
|
|
public int FileRefOpen(TypedPtr<AFCCommConnection> conn, string path, Int64 mode, out Int64 handle)
|
|
{
|
|
return AFC.FileRefOpen(conn, path, mode, out handle);
|
|
}
|
|
|
|
public int FileRefRead(TypedPtr<AFCCommConnection> conn, Int64 handle, byte[] buffer, ref uint len)
|
|
{
|
|
return AFC.FileRefRead(conn, handle, buffer, ref len);
|
|
}
|
|
|
|
public int FileRefSeek(TypedPtr<AFCCommConnection> conn, Int64 handle, Int64 pos, Int64 origin)
|
|
{
|
|
return AFC.FileRefSeek(conn, handle, pos, origin);
|
|
}
|
|
|
|
public int FileRefSetFileSize(TypedPtr<AFCCommConnection> conn, Int64 handle, uint size)
|
|
{
|
|
return AFC.FileRefSetFileSize(conn, handle, size);
|
|
}
|
|
|
|
public int FileRefTell(TypedPtr<AFCCommConnection> conn, Int64 handle, ref uint position)
|
|
{
|
|
return AFC.FileRefTell(conn, handle, ref position);
|
|
}
|
|
|
|
public int FileRefWrite(TypedPtr<AFCCommConnection> conn, Int64 handle, byte[] buffer, uint len)
|
|
{
|
|
return AFC.FileRefWrite(conn, handle, buffer, len);
|
|
}
|
|
|
|
public int FlushData(TypedPtr<AFCCommConnection> conn, Int64 handle)
|
|
{
|
|
return AFC.FlushData(conn, handle);
|
|
}
|
|
|
|
public int KeyValueClose(TypedPtr<AFCDictionary> dict)
|
|
{
|
|
return AFC.KeyValueClose(dict);
|
|
}
|
|
|
|
public int KeyValueRead(TypedPtr<AFCDictionary> dict, out IntPtr key, out IntPtr val)
|
|
{
|
|
return AFC.KeyValueRead(dict, out key, out val);
|
|
}
|
|
|
|
public int RemovePath(TypedPtr<AFCCommConnection> conn, string path)
|
|
{
|
|
return AFC.RemovePath(conn, path);
|
|
}
|
|
|
|
public int RenamePath(TypedPtr<AFCCommConnection> conn, string OldPath, string NewPath)
|
|
{
|
|
return AFC.RenamePath(conn, OldPath, NewPath);
|
|
}
|
|
|
|
public int USBMuxConnectByPort(int DeviceID, short iPort, ref IntPtr outHandle)
|
|
{
|
|
return AFC.USBConnectByPort(DeviceID, iPort, ref outHandle);
|
|
}
|
|
|
|
#region Application Methods
|
|
public class AMDeviceMethods
|
|
{
|
|
// Need to have the path manipulation code in static MobileDevice() to run
|
|
// static int ForceMobileDeviceConstructorToRun;
|
|
static AMDeviceMethods()
|
|
{
|
|
// ForceMobileDeviceConstructorToRun = ForceStaticInit;
|
|
}
|
|
|
|
public static IntPtr CopyDeviceIdentifier(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceCopyDeviceIdentifier((IntPtr)device);
|
|
}
|
|
|
|
public static int Connect(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceConnect((IntPtr)device);
|
|
}
|
|
|
|
public static IntPtr CopyValue(TypedPtr<AppleMobileDeviceConnection> device, uint unknown, TypedPtr<CFString> cfstring)
|
|
{
|
|
return AMDeviceCopyValue((IntPtr)device, unknown, (IntPtr)cfstring);
|
|
}
|
|
|
|
public static int Disconnect(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceDisconnect((IntPtr)device);
|
|
}
|
|
|
|
public static int GetConnectionID(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceGetConnectionID((IntPtr)device);
|
|
}
|
|
|
|
public static int IsPaired(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceIsPaired((IntPtr)device);
|
|
}
|
|
|
|
public static int Pair(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDevicePair((IntPtr)device);
|
|
}
|
|
|
|
public static int Unpair(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceUnpair((IntPtr)device);
|
|
}
|
|
|
|
public static int ValidatePairing(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceValidatePairing((IntPtr)device);
|
|
}
|
|
|
|
public static int LookupApplications(TypedPtr<AppleMobileDeviceConnection> device, IntPtr options, out Dictionary<string, object> AppBundles)
|
|
{
|
|
IntPtr UntypedDict = IntPtr.Zero;
|
|
int Result = AMDeviceLookupApplications((IntPtr)device, options, ref UntypedDict);
|
|
|
|
AppBundles = MobileDevice.ConvertCFDictionaryToDictionaryString(new TypedPtr<CFDictionary>(UntypedDict));
|
|
|
|
return Result;
|
|
}
|
|
|
|
public static int StartSession(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceStartSession((IntPtr)device);
|
|
}
|
|
|
|
public static int StopSession(TypedPtr<AppleMobileDeviceConnection> device)
|
|
{
|
|
return AMDeviceStopSession((IntPtr)device);
|
|
}
|
|
|
|
public static int StartHouseArrestService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> bundleName, IntPtr unknown1, ref IntPtr handle, int unknown2)
|
|
{
|
|
return AMDeviceStartHouseArrestService((IntPtr)device, (IntPtr)bundleName, unknown1, ref handle, unknown2);
|
|
}
|
|
|
|
public static int CreateHouseArrestService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> bundleName, IntPtr unknown1, out TypedPtr<AFCCommConnection> OutConn)
|
|
{
|
|
IntPtr Conn;
|
|
int Result = AMDeviceCreateHouseArrestService((IntPtr)device, (IntPtr)bundleName, unknown1, out Conn);
|
|
OutConn = Conn;
|
|
return Result;
|
|
}
|
|
|
|
public static int StartService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> serviceName, ref IntPtr handle, IntPtr unknown)
|
|
{
|
|
return AMDeviceStartService((IntPtr)device, (IntPtr)serviceName, ref handle, unknown);
|
|
}
|
|
|
|
public static int SecureStartService(TypedPtr<AppleMobileDeviceConnection> device, TypedPtr<CFString> serviceName, int flagsPassInZero, ref IntPtr handle)
|
|
{
|
|
return AMDeviceSecureStartService((IntPtr)device, (IntPtr)serviceName, flagsPassInZero, ref handle);
|
|
}
|
|
|
|
|
|
public static string ServiceConnectionReceive(IntPtr handle)
|
|
{
|
|
byte[] Buffer = new byte[1024];
|
|
|
|
IntPtr UnmanagedPointer = Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0);
|
|
int Ret = AMDServiceConnectionReceive(handle, UnmanagedPointer, 1023, 0);
|
|
Buffer[Ret] = 0;
|
|
int Start = 0;
|
|
string Result = "";
|
|
int I;
|
|
for (I = 0; I < Ret; I++)
|
|
{
|
|
if (Buffer[I] == 0)
|
|
{
|
|
Result += System.Text.Encoding.UTF8.GetString(Buffer, Start, I - Start);
|
|
Start = I + 1;
|
|
}
|
|
}
|
|
if (I > Start)
|
|
{
|
|
Result += System.Text.Encoding.UTF8.GetString(Buffer, Start, I - Start);
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
public static int UninstallApplication(
|
|
TypedPtr<AppleMobileDeviceConnection> device,
|
|
TypedPtr<CFString> ApplicationIdentifier,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceUninstallApplication((IntPtr)device, (IntPtr)ApplicationIdentifier, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int SecureUninstallApplication(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFString> ApplicationIdentifer,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceSecureUninstallApplication(serviceConnection, (IntPtr)DeviceIfConnIsNull, (IntPtr)ApplicationIdentifer, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int SecureTransferPath(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceSecureTransferPath(serviceConnection, (IntPtr)DeviceIfConnIsNull, (IntPtr)UrlPath, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int SecureInstallApplication(
|
|
IntPtr serviceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceSecureInstallApplication(serviceConnection, (IntPtr)DeviceIfConnIsNull, (IntPtr)UrlPath, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int TransferApplication(
|
|
TypedPtr<AppleMobileDeviceConnection> device,
|
|
TypedPtr<CFString> InPackagePath,
|
|
IntPtr UnknownButUnused,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceTransferApplication((IntPtr)device, (IntPtr)InPackagePath, UnknownButUnused, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int SecureUpgradeApplication(
|
|
IntPtr ServiceConnection,
|
|
TypedPtr<AppleMobileDeviceConnection> DeviceIfConnIsNull,
|
|
TypedPtr<CFURL> UrlPath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceSecureUpgradeApplication(ServiceConnection, (IntPtr)DeviceIfConnIsNull, (IntPtr)UrlPath, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int InstallApplication(
|
|
TypedPtr<AppleMobileDeviceConnection> device,
|
|
TypedPtr<CFString> FilePath,
|
|
TypedPtr<CFDictionary> ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData)
|
|
{
|
|
return AMDeviceInstallApplication((IntPtr)device, (IntPtr)FilePath, (IntPtr)ClientOptions, ProgressCallback, UserData);
|
|
}
|
|
|
|
public static int NotificationSubscribe(DeviceNotificationCallback DeviceCallbackHandle)
|
|
{
|
|
IntPtr notification;
|
|
return AMDeviceNotificationSubscribe(DeviceCallbackHandle, 0, 0, 0, out notification);
|
|
}
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static IntPtr AMDeviceCopyDeviceIdentifier(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceConnect(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static IntPtr AMDeviceCopyValue(IntPtr/*AppleMobileDeviceConnection*/ device, uint unknown, IntPtr/*CFString*/ cfstring);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceDisconnect(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceGetConnectionID(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceIsPaired(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDevicePair(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceUnpair(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceValidatePairing(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceLookupApplications(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr options, ref IntPtr appBundles);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceNotificationSubscribe(DeviceNotificationCallback callback, uint unused1, uint unused2, uint unused3, out IntPtr am_device_notification_ptr);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceStartHouseArrestService(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr/*CFString*/ bundleName, IntPtr unknown1, ref IntPtr handle, int unknown2);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceCreateHouseArrestService(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr/*CFString*/ bundleName, IntPtr unknown1, out IntPtr conn);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceStartService(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr/*CFString*/ serviceName, ref IntPtr handle, IntPtr unknown);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceSecureStartService(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr/*CFString*/ serviceName, int flagsPassInZero, ref IntPtr handle);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDServiceConnectionReceive(IntPtr handle, IntPtr buffer, int bufferLen, int unknown);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceStartSession(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceStopSession(IntPtr/*AppleMobileDeviceConnection*/ device);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMRestoreModeDeviceCreate(uint unknown0, int connection_id, uint unknown1);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
public extern static int AMRestoreRegisterForDeviceNotifications(
|
|
DeviceRestoreNotificationCallback dfu_connect,
|
|
DeviceRestoreNotificationCallback recovery_connect,
|
|
DeviceRestoreNotificationCallback dfu_disconnect,
|
|
DeviceRestoreNotificationCallback recovery_disconnect,
|
|
uint unknown0,
|
|
IntPtr user_info);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceUninstallApplication(
|
|
IntPtr/*AppleMobileDeviceConnection*/ device,
|
|
IntPtr/*CFString*/ ApplicationIdentifier,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceSecureUninstallApplication(
|
|
IntPtr serviceConnection,
|
|
IntPtr/*AppleMobileDeviceConnection*/ DeviceIfConnIsNull,
|
|
IntPtr/*CFString*/ ApplicationIdentifer,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceSecureTransferPath(
|
|
IntPtr serviceConnection,
|
|
IntPtr/*AppleMobileDeviceConnection*/ DeviceIfConnIsNull,
|
|
IntPtr/*CFURL*/ UrlPath,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceSecureInstallApplication(
|
|
IntPtr serviceConnection,
|
|
IntPtr/*AppleMobileDeviceConnection*/ DeviceIfConnIsNull,
|
|
IntPtr/*CFURL*/ UrlPath,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceTransferApplication(
|
|
IntPtr/*AppleMobileDeviceConnection*/ device,
|
|
IntPtr/*CFString*/ InPackagePath,
|
|
IntPtr UnknownButUnused,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceSecureUpgradeApplication(
|
|
IntPtr ServiceConnection,
|
|
IntPtr/*AppleMobileDeviceConnection*/ DeviceIfConnIsNull,
|
|
IntPtr/*CFURL*/ UrlPath,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMDeviceInstallApplication(
|
|
IntPtr/*AppleMobileDeviceConnection*/ device,
|
|
IntPtr/*CFString*/ FilePath,
|
|
IntPtr/*CFDictionary*/ ClientOptions,
|
|
DeviceInstallationCallback ProgressCallback,
|
|
IntPtr UserData);
|
|
|
|
// the unknown goes into the 4th dword in the connection struct. if non-zero, winsock send() won't get called in AMDServiceConnectionSend AFAIK
|
|
// the only option is "CloseOnInvalidate" (CFBoolean type, defaults to false)
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static IntPtr AMDServiceConnectionCreate(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr UnknownTypically0, IntPtr OptionsDictionary);
|
|
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AMSBeginSync(IntPtr/*AppleMobileDeviceConnection*/ device, IntPtr OuterIn8, IntPtr OuterIn12, IntPtr OuterIn16);
|
|
}
|
|
#endregion
|
|
|
|
#region AFC Operations
|
|
|
|
public int DirectoryRead(TypedPtr<AFCCommConnection> conn, IntPtr dir, ref string buffer)
|
|
{
|
|
int ret;
|
|
|
|
IntPtr ptr = IntPtr.Zero;
|
|
ret = AFC.DirectoryRead((IntPtr)conn, dir, ref ptr);
|
|
if ((ret == 0) && (ptr != IntPtr.Zero))
|
|
{
|
|
buffer = Marshal.PtrToStringAnsi(ptr);
|
|
}
|
|
else
|
|
{
|
|
buffer = null;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public class AFC
|
|
{
|
|
public static int ConnectionClose(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFCConnectionClose((IntPtr)conn);
|
|
}
|
|
|
|
public static int ConnectionInvalidate(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFCConnectionInvalidate((IntPtr)conn);
|
|
}
|
|
|
|
public static int ConnectionIsValid(TypedPtr<AFCCommConnection> conn)
|
|
{
|
|
return AFCConnectionIsValid((IntPtr)conn);
|
|
}
|
|
|
|
public static int ConnectionOpen(IntPtr handle, uint io_timeout, out TypedPtr<AFCCommConnection> OutConn)
|
|
{
|
|
IntPtr Conn;
|
|
int Result = AFCConnectionOpen(handle, io_timeout, out Conn);
|
|
OutConn = Conn;
|
|
return Result;
|
|
}
|
|
|
|
public static int DeviceInfoOpen(IntPtr handle, ref IntPtr dict)
|
|
{
|
|
return AFCDeviceInfoOpen(handle, ref dict);
|
|
}
|
|
|
|
public static int DirectoryClose(TypedPtr<AFCCommConnection> conn, IntPtr dir)
|
|
{
|
|
return AFCDirectoryClose((IntPtr)conn, dir);
|
|
}
|
|
|
|
public static int DirectoryCreate(TypedPtr<AFCCommConnection> conn, string path)
|
|
{
|
|
return AFCDirectoryCreate((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path));
|
|
}
|
|
|
|
public static int DirectoryOpen(TypedPtr<AFCCommConnection> conn, string path, ref IntPtr dir)
|
|
{
|
|
return AFCDirectoryOpen((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path), ref dir);
|
|
}
|
|
|
|
public static int DirectoryRead(TypedPtr<AFCCommConnection> conn, IntPtr dir, ref IntPtr dirent)
|
|
{
|
|
return AFCDirectoryRead((IntPtr)conn, dir, ref dirent);
|
|
}
|
|
|
|
public static int FileInfoOpen(TypedPtr<AFCCommConnection> conn, string path, out TypedPtr<AFCDictionary> OutDict)
|
|
{
|
|
IntPtr UntypedDict;
|
|
int Result = AFCFileInfoOpen((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path), out UntypedDict);
|
|
OutDict = UntypedDict;
|
|
|
|
return Result;
|
|
}
|
|
|
|
public static int FileRefClose(TypedPtr<AFCCommConnection> conn, Int64 handle)
|
|
{
|
|
return AFCFileRefClose((IntPtr)conn, handle);
|
|
}
|
|
|
|
public static int FileRefOpen(TypedPtr<AFCCommConnection> conn, string path, Int64 mode, out Int64 handle)
|
|
{
|
|
return AFCFileRefOpen((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path), mode, out handle);
|
|
}
|
|
|
|
public static int FileRefRead(TypedPtr<AFCCommConnection> conn, Int64 handle, byte[] buffer, ref uint len)
|
|
{
|
|
return AFCFileRefRead((IntPtr)conn, handle, buffer, ref len);
|
|
}
|
|
|
|
public static int FileRefSetFileSize(TypedPtr<AFCCommConnection> conn, Int64 handle, uint size)
|
|
{
|
|
return AFCFileRefSetFileSize((IntPtr)conn, handle, size);
|
|
}
|
|
|
|
public static int FileRefSeek(TypedPtr<AFCCommConnection> conn, Int64 handle, Int64 pos, Int64 origin)
|
|
{
|
|
return AFCFileRefSeek((IntPtr)conn, handle, pos, origin);
|
|
}
|
|
|
|
public static int FileRefTell(TypedPtr<AFCCommConnection> conn, Int64 handle, ref uint position)
|
|
{
|
|
return AFCFileRefTell((IntPtr)conn, handle, ref position);
|
|
}
|
|
|
|
public static int FileRefWrite(TypedPtr<AFCCommConnection> conn, Int64 handle, byte[] buffer, uint len)
|
|
{
|
|
return AFCFileRefWrite((IntPtr)conn, handle, buffer, len);
|
|
}
|
|
|
|
public static int FlushData(TypedPtr<AFCCommConnection> conn, Int64 handle)
|
|
{
|
|
return AFCFlushData((IntPtr)conn, handle);
|
|
}
|
|
|
|
public static int KeyValueClose(TypedPtr<AFCDictionary> dict)
|
|
{
|
|
return AFCKeyValueClose((IntPtr)dict);
|
|
}
|
|
|
|
public static int KeyValueRead(TypedPtr<AFCDictionary> dict, out IntPtr key, out IntPtr val)
|
|
{
|
|
return AFCKeyValueRead((IntPtr)dict, out key, out val);
|
|
}
|
|
|
|
public static int RemovePath(TypedPtr<AFCCommConnection> conn, string path)
|
|
{
|
|
return AFCRemovePath((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path));
|
|
}
|
|
|
|
public static int RenamePath(TypedPtr<AFCCommConnection> conn, string OldPath, string NewPath)
|
|
{
|
|
return AFCRenamePath((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(OldPath), MobileDevice.StringToFileSystemRepresentation(NewPath));
|
|
}
|
|
|
|
public static int USBConnectByPort(int DeviceID, short iPort, ref IntPtr outHandle)
|
|
{
|
|
return USBMuxConnectByPort(DeviceID, iPort, ref outHandle);
|
|
}
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCConnectionClose(IntPtr/*AFCCommConnection*/ conn);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCConnectionInvalidate(IntPtr/*AFCCommConnection*/ conn);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCConnectionIsValid(IntPtr/*AFCCommConnection*/ conn);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCConnectionOpen(IntPtr handle, uint io_timeout, out IntPtr/*AFCCommConnection*/ conn);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCDeviceInfoOpen(IntPtr handle, ref IntPtr dict);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCDirectoryClose(IntPtr/*AFCCommConnection*/ conn, IntPtr dir);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCDirectoryCreate(IntPtr/*AFCCommConnection*/ conn, byte[] path);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCDirectoryOpen(IntPtr/*AFCCommConnection*/ conn, byte[] path, ref IntPtr dir);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCDirectoryRead(IntPtr/*AFCCommConnection*/ conn, IntPtr dir, ref IntPtr dirent);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileInfoOpen(IntPtr/*AFCCommConnection*/ conn, byte[] path, out IntPtr OutDict);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefClose(IntPtr/*AFCCommConnection*/ conn, Int64 handle);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefOpen(IntPtr/*AFCCommConnection*/ conn, byte[] path, Int64 mode, out Int64 handle);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefRead(IntPtr/*AFCCommConnection*/ conn, Int64 handle, byte[] buffer, ref uint len);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefSeek(IntPtr/*AFCCommConnection*/ conn, Int64 handle, Int64 pos, Int64 origin);
|
|
|
|
// FIXME - not working, arguments?
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
public extern static int AFCFileRefSetFileSize(IntPtr/*AFCCommConnection*/ conn, Int64 handle, uint size);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefTell(IntPtr/*AFCCommConnection*/ conn, Int64 handle, ref uint position);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFileRefWrite(IntPtr/*AFCCommConnection*/ conn, Int64 handle, byte[] buffer, uint len);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCFlushData(IntPtr/*AFCCommConnection*/ conn, Int64 handle);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCKeyValueClose(IntPtr dict);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCKeyValueRead(IntPtr dict, out IntPtr key, out IntPtr val);
|
|
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCRemovePath(IntPtr/*AFCCommConnection*/ conn, byte[] path);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int AFCRenamePath(IntPtr/*AFCCommConnection*/ conn, byte[] old_path, byte[] new_path);
|
|
|
|
[DllImport(DLLName, CallingConvention = CallingConvention.Cdecl)]
|
|
private extern static int USBMuxConnectByPort(int connectionID, short iPhone_port_network_byte_order, ref IntPtr outHandle);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
internal partial class MobileDevice
|
|
{
|
|
static public MobileDeviceImpl DeviceImpl = null;
|
|
|
|
static MobileDevice()
|
|
{
|
|
if (Environment.OSVersion.Platform == PlatformID.MacOSX || Environment.OSVersion.Platform == PlatformID.Unix)
|
|
{
|
|
DeviceImpl = new MobileDeviceOSX();
|
|
}
|
|
else
|
|
{
|
|
string dllPath11 = Microsoft.Win32.Registry.GetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Apple Inc.\\Apple Mobile Device Support\\Shared", "iTunesMobileDeviceDLL", null) as string;
|
|
string dllPath12 = Microsoft.Win32.Registry.GetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Apple Inc.\\Apple Mobile Device Support\\Shared", "MobileDeviceDLL", null) as string;
|
|
string dllPath12WindowsStore = ITunesFinder.FindWindowsStoreITunesDLL();
|
|
|
|
if ((!String.IsNullOrEmpty(dllPath12) && File.Exists(dllPath12)) || (!String.IsNullOrEmpty(dllPath12WindowsStore) && File.Exists(dllPath12WindowsStore)))
|
|
{
|
|
DeviceImpl = new MobileDeviceWiniTunes12();
|
|
}
|
|
else if (!String.IsNullOrEmpty(dllPath11) && File.Exists(dllPath11))
|
|
{
|
|
DeviceImpl = new MobileDeviceWiniTunes11();
|
|
}
|
|
}
|
|
|
|
// Initialize the CoreFoundation bindings
|
|
InitializeCoreFoundation();
|
|
}
|
|
|
|
/*
|
|
Valid Value Names:
|
|
ActivationState
|
|
ActivationStateAcknowledged
|
|
BasebandBootloaderVersion
|
|
BasebandVersion
|
|
BluetoothAddress
|
|
BuildVersion
|
|
DeviceCertificate
|
|
DeviceClass
|
|
DeviceName
|
|
DevicePublicKey
|
|
FirmwareVersion
|
|
HostAttached
|
|
IntegratedCircuitCardIdentity
|
|
InternationalMobileEquipmentIdentity
|
|
InternationalMobileSubscriberIdentity
|
|
ModelNumber
|
|
PhoneNumber
|
|
ProductType
|
|
ProductVersion
|
|
ProtocolVersion
|
|
RegionInfo
|
|
SBLockdownEverRegisteredKey
|
|
SIMStatus
|
|
SerialNumber
|
|
SomebodySetTimeZone
|
|
TimeIntervalSince1970
|
|
TimeZone
|
|
TimeZoneOffsetFromUTC
|
|
TrustedHostAttached
|
|
UniqueDeviceID
|
|
Uses24HourClock
|
|
WiFiAddress
|
|
iTunesHasConnected
|
|
*/
|
|
|
|
public static string AMDeviceCopyValue(TypedPtr<AppleMobileDeviceConnection> device, string name)
|
|
{
|
|
IntPtr result = DeviceImpl.CopyValue(device, 0, CFStringMakeConstantString(name));
|
|
if (result != IntPtr.Zero)
|
|
{
|
|
return MobileDevice.CFStringGetCString(result);
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("Error: Call to AMDeviceCopyValue failed");
|
|
}
|
|
return String.Empty;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns an error string
|
|
/// </summary>
|
|
public static string GetErrorString(int ErrorValue)
|
|
{
|
|
string Result = GetSpecificErrorString(ErrorValue);
|
|
|
|
if (Result == null)
|
|
{
|
|
Result = String.Format("Unknown error 0x{0:X}", ErrorValue);
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a human readable description of the error from the mobile device or null if there isn't one
|
|
/// </summary>
|
|
public static string GetSpecificErrorString(int ErrorValue)
|
|
{
|
|
switch ((uint)ErrorValue)
|
|
{
|
|
case 0:
|
|
return "Success.";
|
|
|
|
case 0xE8000002:
|
|
return "Bad Header Error";
|
|
|
|
case 0xE8000003:
|
|
return "No Resources Error";
|
|
|
|
case 0xE8000004:
|
|
return "Read Error";
|
|
|
|
case 0xE8000005:
|
|
return "Write Error";
|
|
|
|
case 0xE8000006:
|
|
return "Unknown Packet Error";
|
|
|
|
case 0xE8000007:
|
|
return "Invalid Argument Error";
|
|
|
|
case 0xE8000008:
|
|
return "Not Found Error";
|
|
|
|
case 0xE8000009:
|
|
return "Is Directory Error";
|
|
|
|
case 0xE800000A:
|
|
return "Permission Error";
|
|
|
|
case 0xE800000B:
|
|
return "Not Connected Error";
|
|
|
|
case 0xE800000C:
|
|
return "Time Out Error";
|
|
|
|
case 0xE800000D:
|
|
return "Overrun Error";
|
|
|
|
case 0xE800000E:
|
|
return "EOF Error";
|
|
|
|
case 0xE800000F:
|
|
return "Unsupported Error";
|
|
|
|
case 0xE8000010:
|
|
return "File Exists Error";
|
|
|
|
case 0xE8000011:
|
|
return "Busy Error";
|
|
|
|
case 0xE8000012:
|
|
return "Crypto Error";
|
|
|
|
case 0xE8000013:
|
|
return "Invalid Response Error";
|
|
|
|
case 0xE8000014:
|
|
return "Missing Key Error";
|
|
|
|
case 0xE8000015:
|
|
return "Missing Value Error";
|
|
|
|
case 0xE8000016:
|
|
return "Get Prohibited Error";
|
|
|
|
case 0xE8000017:
|
|
return "Set Prohibited Error";
|
|
|
|
case 0xE8000018:
|
|
return "Time Out Error";
|
|
|
|
case 0xE8000019:
|
|
return "Immutable Value Error";
|
|
|
|
case 0xE800001A:
|
|
return "Password Protected Error";
|
|
|
|
case 0xE800001B:
|
|
return "Missing Host ID Error";
|
|
|
|
case 0xE800001C:
|
|
return "Invalid Host ID Error";
|
|
|
|
case 0xE800001D:
|
|
return "Session Active Error";
|
|
|
|
case 0xE800001E:
|
|
return "Session Inactive Error";
|
|
|
|
case 0xE800001F:
|
|
return "Missing Session ID Error";
|
|
|
|
case 0xE8000020:
|
|
return "Invalid Session ID Error";
|
|
|
|
case 0xE8000021:
|
|
return "Missing Service Error";
|
|
|
|
case 0xE8000022:
|
|
return "Invalid Service Error";
|
|
|
|
case 0xE8000023:
|
|
return "Invalid Checkin Error";
|
|
|
|
case 0xE8000024:
|
|
return "Checkin Timeout Error";
|
|
|
|
case 0xE8000025:
|
|
return "Missing Pair Record Error";
|
|
|
|
case 0xE8000026:
|
|
return "Invalid Activation Record Error";
|
|
|
|
case 0xE8000027:
|
|
return "Missing Activation Error";
|
|
|
|
case 0xE8000028:
|
|
return "Wrong Droid Error";
|
|
|
|
case 0xE8000029:
|
|
return "SU Verification Error";
|
|
|
|
case 0xE800002A:
|
|
return "SU Patch Error";
|
|
|
|
case 0xE800002B:
|
|
return "SU Firmware Error";
|
|
|
|
case 0xE800002C:
|
|
return "Provisioning Profile Not Valid";
|
|
|
|
case 0xE800002D:
|
|
return "Send Message Error";
|
|
|
|
case 0xE800002E:
|
|
return "Receive Message Error";
|
|
|
|
case 0xE800002F:
|
|
return "Missing Options Error";
|
|
|
|
case 0xE8000030:
|
|
return "Missing Image Type Error";
|
|
|
|
case 0xE8000031:
|
|
return "Digest Failed Error";
|
|
|
|
case 0xE8000032:
|
|
return "Start Service Error";
|
|
|
|
case 0xE8000033:
|
|
return "Invalid Disk Image Error";
|
|
|
|
case 0xE8000034:
|
|
return "Missing Digest Error";
|
|
|
|
case 0xE8000035:
|
|
return "Mux Error";
|
|
|
|
case 0xE8000036:
|
|
return "Application Already Installed Error";
|
|
|
|
case 0xE8000037:
|
|
return "Application Move Failed Error";
|
|
|
|
case 0xE8000038:
|
|
return "Application SINF Capture Failed Error";
|
|
|
|
case 0xE8000039:
|
|
return "Application Sandbox Failed Error";
|
|
|
|
case 0xE800003A:
|
|
return "Application Verification Failed Error";
|
|
|
|
case 0xE800003B:
|
|
return "Archive Destructor Failed Error";
|
|
|
|
case 0xE800003C:
|
|
return "Bundle Verification Failed Error";
|
|
|
|
case 0xE800003D:
|
|
return "Carrier Bundle Copy Failed Error";
|
|
|
|
case 0xE800003E:
|
|
return "Carrier Bundle Directory Creation Failed Error";
|
|
|
|
case 0xE800003F:
|
|
return "Carrier Bundle Missing Supported SIMs Error";
|
|
|
|
case 0xE8000040:
|
|
return "Comm Center Notification Failed Error";
|
|
|
|
case 0xE8000041:
|
|
return "COntainer Creation Failed Error";
|
|
|
|
case 0xE8000042:
|
|
return "Container P0wn Failed Error";
|
|
|
|
case 0xE8000043:
|
|
return "Container Removal Failed Error";
|
|
|
|
case 0xE8000044:
|
|
return "Embedded Profile Install Failed Error";
|
|
|
|
case 0xE8000045:
|
|
return "Error Error";
|
|
|
|
case 0xE8000046:
|
|
return "Executable Twiddle Failed Error";
|
|
|
|
case 0xE8000047:
|
|
return "Existence Check Failed Error";
|
|
|
|
case 0xE8000048:
|
|
return "Install Map Upfate Failed Error";
|
|
|
|
case 0xE8000049:
|
|
return "Manifest Capture Failed Error";
|
|
|
|
case 0xE800004A:
|
|
return "Map Generation Failed Error";
|
|
|
|
case 0xE800004B:
|
|
return "Missing Bundle Executable Error";
|
|
|
|
case 0xE800004C:
|
|
return "Missing Bundle Identifier Error";
|
|
|
|
case 0xE800004D:
|
|
return "Missing Bundle Path Error";
|
|
|
|
case 0xE800004E:
|
|
return "Missing Container Error";
|
|
|
|
case 0xE800004F:
|
|
return "Notification Failed Error";
|
|
|
|
case 0xE8000050:
|
|
return "Package Extraction Failed Error";
|
|
|
|
case 0xE8000051:
|
|
return "Package Inspection Failed Error";
|
|
|
|
case 0xE8000052:
|
|
return "Package Move Failed Error";
|
|
|
|
case 0xE8000053:
|
|
return "Path Conversion Failed Error";
|
|
|
|
case 0xE8000054:
|
|
return "Restore Container Failed Error";
|
|
|
|
case 0xE8000055:
|
|
return "Seatbelt Profile Removal Failed Error";
|
|
|
|
case 0xE8000056:
|
|
return "Stage Creation Failed Error";
|
|
|
|
case 0xE8000057:
|
|
return "Symlink Failed Error";
|
|
|
|
case 0xE8000058:
|
|
return "iTunes Artwork Capture Failed Error";
|
|
|
|
case 0xE8000059:
|
|
return "iTunes Metadata Capture Failed Error";
|
|
|
|
case 0xE800005A:
|
|
return "Already Archived Error";
|
|
|
|
case 0xE8000067:
|
|
return "Device not Included in Provisioning Profile (0xE8000067)";
|
|
|
|
case 0xE8008001:
|
|
return "Unknown code signature related error (0xE8008001); your executable may be missing or misnamed (e.g., underscore issue)";
|
|
|
|
case 0xE8008015:
|
|
return "No matching mobile provision for this application (0xE8008015). Please ensure the mobile provision used includes the target device.";
|
|
|
|
case 0xE8008016:
|
|
return "There is a problem with the entitlements for this application (0xE8008016).";
|
|
|
|
case 0xE8008017:
|
|
return "Unable to validate signature (there is a problem with a signed code resource) (0xE8008017)";
|
|
|
|
case 0xE8008018:
|
|
return "The identity used to sign the executable is no longer valid (0xE8008018)";
|
|
|
|
case 0xE8008019:
|
|
return "Missing or invalid code signature (0xE8008019)";
|
|
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|