size_t found;

found = path.find_last_of(kPathSeparators);

return path.substr(0, found);

std::string path_str(path);

replace_all(path_str, "\\", "/");

return path_str;

const char *result_attempt =

CFStringGetCStringPtr(cfstring, kCFStringEncodingUTF8);

char cfstring_buffer[2000];

if (result_attempt == NULL) {

if (CFStringGetCString(cfstring, cfstring_buffer, 2000,

kCFStringEncodingUTF8)) {

return std::string(cfstring_buffer);

}

}

return std::string(result_attempt);

start_session_mutex.lock();

if (devices[device_identifier].sessions < 1) {

const DeviceInfo *device_info = devices[device_identifier].device_info;

UNLOCK_MUTEX_AND_RETURN_IF_FAILED_RESULT(AMDeviceConnect(device_info),

start_session_mutex);

assert(AMDeviceIsPaired(device_info));

UNLOCK_MUTEX_AND_RETURN_IF_FAILED_RESULT(

AMDeviceValidatePairing(device_info), start_session_mutex);

UNLOCK_MUTEX_AND_RETURN_IF_FAILED_RESULT(AMDeviceStartSession(device_info),

start_session_mutex);

}

++devices[device_identifier].sessions;

start_session_mutex.unlock();

return 0;

stop_session_mutex.lock();

if (--devices[device_identifier].sessions < 1) {

const DeviceInfo *device_info = devices[device_identifier].device_info;

AMDeviceStopSession(device_info);

AMDeviceDisconnect(device_info);

}

stop_session_mutex.unlock();

const char *property_name) {

const DeviceInfo *device_info = devices[device_identifier].device_info;

std::string result;

if (!start_session(device_identifier)) {

CFStringRef cfstring = create_CFString(property_name);

result = get_cstring_from_cfstring(

AMDeviceCopyValue(device_info, NULL, cfstring));

CFRelease(cfstring);

}

stop_session(device_identifier);

return result;

if (m.count(key)) {

m.erase(key);

}

const std::string &application_identifier) {

if (!devices.count(device_identifier)) {

return;

}

if (devices[device_identifier]

.apps_cache[application_identifier]

.afc_connection) {

AFCConnectionRef afc_connection_to_close =

devices[device_identifier]

.apps_cache[application_identifier]

.afc_connection;

AFCConnectionClose(afc_connection_to_close);

devices[device_identifier].apps_cache.erase(application_identifier);

}

if (!devices.count(device_identifier)) {

return;

}

if (devices[device_identifier].apps_cache.size()) {

std::map<std::string, ApplicationCache> apps_cache_clone =

devices[device_identifier].apps_cache;

for (auto const &key_value_pair : apps_cache_clone) {

cleanup_file_resources(device_identifier, key_value_pair.first);

}

devices[device_identifier].apps_cache.clear();

}

result["status"] = get_device_status(device_identifier);

result["productType"] =

get_device_property_value(device_identifier, "ProductType");

result["deviceName"] =

get_device_property_value(device_identifier, "DeviceName");

result["productVersion"] =

get_device_property_value(device_identifier, kProductVersion);

result["deviceColor"] =

get_device_property_value(device_identifier, "DeviceColor");

result["deviceClass"] =

get_device_property_value(device_identifier, "DeviceClass");

// available values:

// "BluetoothAddress","BoardId","CPUArchitecture","ChipID","DeviceClass",

// "DeviceColor","DeviceName","FirmwareVersion","HardwareModel",

// "ModelNumber","ProductType","ProductVersion","UniqueDeviceID","WiFiAddress"

result[kIsUSBConnected] = devices[device_identifier].isUSBConnected;

result[kIsWiFiConnected] = devices[device_identifier].isWiFiConnected;

get_device_properties(device_identifier, result);

std::string device_identifier, json &result) {

/*

int interface_type = AMDeviceGetInterfaceType(device_ptr->device_info);

if (interface_type == kUSBInterfaceType ||

interface_type == kWIFIInterfaceType) {

if (devices.count(device_identifier)) {

devices[device_identifier].device_info = device_ptr->device_info;

result[kEventString] = kDeviceUpdated;

} else {

devices[device_identifier] = {device_ptr->device_info, nullptr};

result[kEventString] = kDeviceFound;

}

if (interface_type == kUSBInterfaceType) {

devices[device_identifier].isUSBConnected = 1;

} else {

devices[device_identifier].isWiFiConnected = 1;

}

update_device_result(device_identifier, result);

if (result["deviceClass"] == "AppleTV") {

// We do not support AppleTV devices

result = nullptr;

}

}

std::string device_identifier = get_cstring_from_cfstring(

AMDeviceCopyDeviceIdentifier(device_ptr->device_info));

json result = nullptr;

result[kDeviceId] = device_identifier;

switch (device_ptr->msg) {

case kADNCIMessageConnected: {

on_device_found(device_ptr, device_identifier, result);

break;

}

case kADNCIMessageDisconnected: {

if (devices.count(device_identifier)) {

int interface_type = AMDeviceGetInterfaceType(device_ptr->device_info);

if (interface_type == kUSBInterfaceType) {

devices[device_identifier].isUSBConnected = 0;

} else if (interface_type == kWIFIInterfaceType) {

devices[device_identifier].isWiFiConnected = 0;

}

if (!devices[device_identifier].isUSBConnected &&

!devices[device_identifier].isWiFiConnected) {

if (devices[device_identifier].apps_cache.size()) {

cleanup_file_resources(device_identifier);

}

devices.erase(device_identifier);

result[kEventString] = kDeviceLost;

} else {

result[kEventString] = kDeviceUpdated;

update_device_result(device_identifier, result);

}

}

break;

}

case kADNCIMessageUnknown: {

result[kEventString] = kDeviceUnknown;

break;

}

case kADNCIMessageTrusted: {

on_device_found(device_ptr, device_identifier, result);

break;

}

}

if (result != nullptr) {

print(result);

}

std::string str(std::getenv(kPathUpperCase));

str = str.append(

";C:\\Program Files\\Common Files\\Apple\\Apple Application "

"Support;C:\\Program Files\\Common Files\\Apple\\Mobile Device Support;");

str = str.append(";C:\\Program Files (x86)\\Common Files\\Apple\\Apple "

"Application Support;C:\\Program Files (x86)\\Common "

"Files\\Apple\\Mobile Device Support;");

SetEnvironmentVariable(kPathUpperCase, str.c_str());

add_dll_paths_to_environment();

mobile_device_dll = LoadLibrary("MobileDevice.dll");

if (!mobile_device_dll) {

print_error("Could not load MobileDevice.dll", kNullMessageId,

kNullMessageId);

return 1;

}

core_foundation_dll = LoadLibrary("CoreFoundation.dll");

if (!core_foundation_dll) {

print_error("Could not load CoreFoundation.dll", kNullMessageId,

kNullMessageId);

return 1;

}

return 0;

HANDLE notify_function = nullptr;

int result = AMDeviceNotificationSubscribe(device_notification_callback, 0, 0,

0, &notify_function);

if (result) {

print_error("Could not attach notification callback", kNullMessageId,

kNullMessageId);

}

return result;

int subscribe_for_notifications_result = subscribe_for_notifications();

if (subscribe_for_notifications_result) {

return;

}

#ifdef _WIN32

run_loop_ptr CFRunLoopRun =

(run_loop_ptr)GetProcAddress(core_foundation_dll, "CFRunLoopRun");

#endif

CFRunLoopRun();

#ifndef _WIN32

static void (*SSL_free)(void *);

if (!SSL_free) {

SSL_free = (void (*)(void *))dlsym(RTLD_DEFAULT, "SSL_free");

}

#endif

if (connection->sslContext != NULL) {

SSL_free(connection->sslContext);

connection->sslContext = NULL;

}

const char *service_name,

std::string method_id, bool should_log_error,

bool skip_cache) {

start_service_mutex.lock();

ServiceInfo serviceInfoResult = {};

if (!devices.count(device_identifier)) {

if (should_log_error)

print_error("Device not found", device_identifier, method_id,

kAMDNotFoundError);

start_service_mutex.unlock();

return serviceInfoResult;

}

// Track the Debug Service Name

devices[device_identifier].debugServiceName = (char *)service_name;

if (!skip_cache && devices[device_identifier].services.count(service_name)) {

start_service_mutex.unlock();

return devices[device_identifier].services[service_name];

}

PRINT_ERROR_AND_RETURN_VALUE_IF_FAILED_RESULT(

start_session(device_identifier), "Could not start device session",

device_identifier, method_id, serviceInfoResult);

CFStringRef cf_service_name = create_CFString(service_name);

ServiceConnRef connection;

unsigned result =

AMDeviceSecureStartService(devices[device_identifier].device_info,

cf_service_name, NULL, &connection);

if (connection && service_name && strcmp(service_name, kDebugServer) == 0) {

// We have to disable SSL on old service name

disable_ssl_for_connection(connection);

}

HANDLE socket = (void *)(size_t)AMDServiceConnectionGetSocket(connection);

stop_session(device_identifier);

CFRelease(cf_service_name);

if (result) {

std::string message("Could not start service ");

message += service_name;

if (should_log_error)

print_error(message.c_str(), device_identifier, method_id, result);

start_service_mutex.unlock();

return serviceInfoResult;

}

serviceInfoResult.socket = socket;

serviceInfoResult.connection = connection;

serviceInfoResult.connection_id = nextServiceConnectionId;

serviceInfoResult.service_name = service_name;

serviceConnections[nextServiceConnectionId] = connection;

nextServiceConnectionId++;

if (!skip_cache) {

devices[device_identifier].services[service_name] = serviceInfoResult;

}

start_service_mutex.unlock();

return serviceInfoResult;

const char *application_identifier,

std::string method_id) {

if (!devices.count(device_identifier)) {

print_error("Device not found", device_identifier, method_id,

kAMDNotFoundError);

return NULL;

}

AFCConnectionRef persistedHouseArrestService =

devices[device_identifier]

.apps_cache[application_identifier]

.afc_connection;

if (persistedHouseArrestService) {

return persistedHouseArrestService;

}

AFCConnectionRef conn = NULL;

start_session(device_identifier);

CFStringRef cf_application_identifier =

create_CFString(application_identifier);

unsigned result =

AMDeviceCreateHouseArrestService(devices[device_identifier].device_info,

cf_application_identifier, 0, &conn);

stop_session(device_identifier);

CFRelease(cf_application_identifier);

if (result) {

std::string message("Could not start house arrest for application ");

message += application_identifier;

print_error(message.c_str(), device_identifier, method_id, result);

return NULL;

}

devices[device_identifier].apps_cache[application_identifier].afc_connection =

conn;

return conn;

std::string method_id) {

// Try New Service

ServiceInfo info = start_secure_service(device_identifier, kNewDebugServer,

method_id, false, false);

#ifndef _WIN32

// mount_image is not available on Windows

if (!info.socket && mount_image(device_identifier, ddi, method_id)) {

info = start_secure_service(device_identifier, kNewDebugServer, method_id,

false, false);

}

#endif

// Try Old service

if (!info.socket) {

info = start_secure_service(device_identifier, kDebugServer, method_id,

false, false);

}

// TODO: We might not need to remount image, image might be being dismounted

// somehow in start_secure_image, so...

#ifndef _WIN32

if (!info.socket && mount_image(device_identifier, ddi, method_id)) {

info = start_secure_service(device_identifier, kDebugServer, method_id,

true, false);

}

#endif

return info;

const char *application_identifier,

std::string &root_path,

std::string &method_id) {

if (devices.count(device_identifier) &&

devices[device_identifier]

.apps_cache[application_identifier]

.afc_connection) {

return devices[device_identifier]

.apps_cache[application_identifier]

.afc_connection;

}

AFCConnectionRef con_ref =

start_house_arrest(device_identifier, application_identifier, method_id);

if (!con_ref) {

return NULL;

}

devices[device_identifier].apps_cache[application_identifier].afc_connection =

con_ref;

return con_ref;

std::string device_identifier,

std::string method_id) {

if (!devices.count(device_identifier)) {

print_error("Device not found", device_identifier, method_id,

kAMDNotFoundError);

return;

}

ServiceInfo serviceInfo = start_secure_service(

device_identifier, kInstallationProxy, method_id, true, false);

if (!serviceInfo.socket) {

return;

}

CFStringRef appid_cfstring = create_CFString(application_identifier.c_str());

DeviceInfo *deviceInfo = devices[device_identifier].device_info;

CFDictionaryRef params = CFDictionaryCreate(NULL, {}, {}, 0, NULL, NULL);

unsigned result = AMDeviceSecureUninstallApplication(

serviceInfo.connection, deviceInfo, appid_cfstring, params, NULL);

CFRelease(appid_cfstring);

if (result) {

print_error("Could not uninstall application", device_identifier, method_id,

result);

} else {

print(json({{kResponse, "Successfully uninstalled application"},

{kId, method_id},

{kDeviceId, device_identifier}}));

// AppleFileConnection and HouseArrest deal with the files on an application

// so they have to be removed when uninstalling the application

cleanup_file_resources(device_identifier, application_identifier);

}

std::string device_identifier, std::string method_id) {

if (!devices.count(device_identifier)) {

print_error("Device not found", device_identifier, method_id,

kAMDNotFoundError);

return;

}

#ifdef _WIN32

if (install_path.compare(0, kFilePrefix.size(), kFilePrefix)) {

install_path = kFilePrefix + install_path;

}

install_path = windows_path_to_unix(install_path);

install_path = url_encode_without_forward_slash_and_colon(install_path);

#endif

int session_result = start_session(device_identifier);

if (session_result) {

print_error("Could not start device session", device_identifier, method_id,

session_result);

return;

}

CFStringRef path = create_CFString(install_path.c_str());

CFURLRef local_app_url =

#ifdef _WIN32

CFURLCreateWithString(NULL, path, NULL);

#else

CFURLCreateWithFileSystemPath(NULL, path, kCFURLPOSIXPathStyle, true);

#endif

CFRelease(path);

if (!local_app_url) {

stop_session(device_identifier);

print_error("Could not parse application path", device_identifier,

method_id, kAMDAPIInternalError);

return;

}

CFStringRef cf_package_type = create_CFString("PackageType");

CFStringRef cf_developer = create_CFString("Developer");

const void *keys_arr[] = {cf_package_type};

const void *values_arr[] = {cf_developer};

CFDictionaryRef options =

CFDictionaryCreate(NULL, keys_arr, values_arr, 1, NULL, NULL);

unsigned transfer_result =

AMDeviceSecureTransferPath(0, devices[device_identifier].device_info,

local_app_url, options, NULL, 0);

stop_session(device_identifier);

if (transfer_result) {

print_error("Could not transfer application", device_identifier, method_id,

transfer_result);

return;

}

session_result = start_session(device_identifier);

if (session_result) {

print_error("Could not start device session", device_identifier, method_id,

session_result);

return;

}

unsigned install_result = AMDeviceSecureInstallApplication(

0, devices[device_identifier].device_info, local_app_url, options, NULL,

0);

CFRelease(cf_package_type);

CFRelease(cf_developer);

stop_session(device_identifier);

if (install_result) {

print_error("Could not install application", device_identifier, method_id,

install_result);

return;

}

print(json({{kResponse, "Successfully installed application"},

{kId, method_id},

{kDeviceId, device_identifier}}));

// In case this is a REinstall we need to invalidate cached file resources

cleanup_file_resources(device_identifier);

std::string arg, std::string method_id) {

std::thread([operation, arg, method_id]() {

operation(arg, method_id);

}).detach();

std::string),

json method_args, std::string method_id) {

std::string first_arg = method_args[0].get<std::string>();

std::vector<std::string> device_identifiers =

method_args[1].get<std::vector<std::string>>();

for (std::string &device_identifier : device_identifiers)

std::thread([operation, first_arg, device_identifier, method_id]() {

operation(first_arg, device_identifier, method_id);

}).detach();

clean_con_resources_mutex.lock();

ConnectionMessageData *connectionMessageData =

reinterpret_cast<ConnectionMessageData *>(data);

ServiceConnRef conn = connectionMessageData->conn;

devices[connectionMessageData->device_identifier].services.erase(

connectionMessageData->service_name.c_str());

AMDServiceConnectionInvalidate(conn);

clean_con_resources_mutex.unlock();

receive_con_message_mutex.lock();

ServiceConnRef conn = data.conn;

TimeoutOutputData *timeoutOutputData =

setTimeout(data.timeout, &data, clean_con_resources);

std::map<std::string, boost::any> dict;

char *buffer = new char[4];

int bytes_read = AMDServiceConnectionReceive(conn, buffer, 4);

if (bytes_read > 0) {

unsigned long res = ntohl(*((unsigned long *)buffer));

delete[] buffer;

buffer = new char[res];

bytes_read = AMDServiceConnectionReceive(conn, buffer, res);

if (bytes_read > 0) {

Plist::readPlist(buffer, res, dict);

}

}

clearTimeout(timeoutOutputData);

delete[] buffer;

receive_con_message_mutex.unlock();

return dict;

CFDictionaryRef message) {

return AMDServiceConnectionSendMessage(serviceConnection, message,

kCFPropertyListXMLFormat_v1_0);

std::stringstream &errors, std::string method_id,

std::string device_identifier) {

char *dir_ent;

files.push_back(dir);

afc_dictionary afc_dict;

afc_dictionary *afc_dict_p = &afc_dict;

unsigned afc_file_info_open_result =

AFCFileInfoOpen(afc_conn_p, dir, &afc_dict_p);

if (afc_file_info_open_result) {

errors << "Could not open file info for file: ";

errors << dir;

errors << '\n';

return;

}

afc_directory afc_dir;

afc_directory *afc_dir_p = &afc_dir;

unsigned err = AFCDirectoryOpen(afc_conn_p, dir, &afc_dir_p);

if (err != 0) {

// Couldn't open dir - was probably a file

return;

}

while (true) {

err = AFCDirectoryRead(afc_conn_p, afc_dir_p, &dir_ent);

if (err != 0) {

// Couldn't read dir

return;

}

if (!dir_ent)

break;

if (strcmp(dir_ent, ".") == 0 || strcmp(dir_ent, "..") == 0)

continue;

char *dir_joined = (char *)malloc(strlen(dir) + strlen(dir_ent) + 2);

strcpy(dir_joined, dir);

if (dir_joined[strlen(dir) - 1] != '/')

strcat(dir_joined, "/");

strcat(dir_joined, dir_ent);

read_dir(afc_conn_p, dir_joined, files, errors, method_id,

device_identifier);

free(dir_joined);

}

unsigned afc_directory_close_result =

AFCDirectoryClose(afc_conn_p, afc_dir_p);

if (afc_directory_close_result) {

errors << "Could not close directory: ";

errors << dir_ent;

errors << '\n';

}

const char *application_identifier, const char *device_path,

std::string method_id) {

list_files_mutex.lock();

std::string device_root(device_path);

AFCConnectionRef afc_conn_p = get_afc_connection(

device_identifier, application_identifier, device_root, method_id);

if (!afc_conn_p) {

print_error("Could not establish AFC Connection", device_identifier,

method_id);

list_files_mutex.unlock();

return;

}

json files;

std::stringstream errors;

std::string device_path_str = windows_path_to_unix(device_path);

read_dir(afc_conn_p, device_path_str.c_str(), files, errors, method_id,

device_identifier);

if (!files.empty()) {

print(json({{kResponse, files},

{kId, method_id},

{kDeviceId, device_identifier}}));

}

if (errors.rdbuf()->in_avail() != 0) {

print_error(errors.str().c_str(), device_identifier, method_id,

kAFCCustomError);

}

cleanup_file_resources(device_identifier, application_identifier);

list_files_mutex.unlock();

AFCConnectionRef connection) {

std::vector<std::string> directories = split(device_path, kUnixPathSeparator);

std::string curent_device_path("");

for (std::string &directory_path : directories) {

if (!directory_path.empty()) {

curent_device_path += kUnixPathSeparator;

curent_device_path += directory_path;

if (AFCDirectoryCreate(connection, curent_device_path.c_str()))

return false;

}

}

return true;

const char *application_identifier,

const std::vector<FileUploadData> &files,

std::string method_id) {

json success_json = json({{kResponse, "Successfully uploaded files"},

{kId, method_id},

{kDeviceId, device_identifier}});

if (!files.size()) {

print(success_json);

return;

}

upload_file_mutex.lock();

std::string afc_destination_str = windows_path_to_unix(files[0].destination);

AFCConnectionRef afc_conn_p =

get_afc_connection(device_identifier, application_identifier,

afc_destination_str, method_id);

if (!afc_conn_p) {

upload_file_mutex.unlock();

// If there is no opened afc connection the get_afc_connection will print

// the error for the operation.

return;

}

// We need to set the size of errors here because we need to access the

// elements by index. If we don't access them by index and use push_back from

// multiple threads, some of them will try to push at the same memory. The

// result of this will be an exception.

std::vector<std::string> errors(files.size());

std::vector<std::thread> file_upload_threads;

// We're only ever going to insert kDeviceUploadFilesBatchSize elements

file_upload_threads.reserve(kDeviceUploadFilesBatchSize);

// Launching a separate thread for each file puts a strain on the OS' memory

// That's why we launch batches of threads - kDeviceUploadFilesBatchSize each

size_t batch_end = files.size() / kDeviceUploadFilesBatchSize + 1;

for (size_t batch_index = 0; batch_index < batch_end; ++batch_index) {

size_t start = batch_index * kDeviceUploadFilesBatchSize;

size_t end = (std::min)((batch_index + 1) * kDeviceUploadFilesBatchSize,

files.size());

for (size_t i = start; i < end; ++i) {

FileUploadData current_file_data = files[i];

file_upload_threads.emplace_back([=, &errors]() -> void {

afc_file_ref file_ref;

std::string source = current_file_data.source;

std::string destination = current_file_data.destination;

FileInfo file_info = get_file_info(source, true);

if (file_info.size >= 0) {

std::string dir_name = get_dirname(destination);

if (ensure_device_path_exists(dir_name, afc_conn_p)) {

std::stringstream error_message;

AFCRemovePath(afc_conn_p, destination.c_str());

error_message << "Could not open file " << destination

<< " for writing";

if (AFCFileRefOpen(afc_conn_p, destination.c_str(),

kAFCFileModeWrite, &file_ref)) {

errors[i] = error_message.str();

return;

}

error_message.str("");

error_message << "Could not write to file: " << destination;

if (AFCFileRefWrite(afc_conn_p, file_ref, &file_info.contents[0],

file_info.size)) {

errors[i] = error_message.str();

return;

}

error_message.str("");

error_message << "Could not close file reference: " << destination;

if (AFCFileRefClose(afc_conn_p, file_ref)) {

errors[i] = error_message.str();

return;

}

} else {

std::string message("Could not create device path for file: ");

message += source;

errors.push_back(message);

}

} else {

std::string message("Could not open file: ");

message += source;

errors.push_back(message);

}

});

}

for (std::thread &file_upload_thread : file_upload_threads) {

file_upload_thread.join();

}

// After a batch is completed we need to empty file_upload_threads so that

// the new batch may take the old one's place

file_upload_threads.clear();

cleanup_file_resources(device_identifier, application_identifier);

upload_file_mutex.unlock();

}

std::vector<std::string> filtered_errors;

std::copy_if(std::begin(errors), std::end(errors),

std::back_inserter(filtered_errors),

[](std::string e) { return e.size() != 0; });

if (!filtered_errors.size()) {

print(success_json);

} else {

print_errors(filtered_errors, device_identifier, method_id,

kAMDAPIInternalError);

}

const char *application_identifier, const char *destination,

std::string method_id) {

delete_file_mutex.lock();

std::string destination_str = windows_path_to_unix(destination);

AFCConnectionRef afc_conn_p = get_afc_connection(