14 files changed, 847 insertions, 142 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 58cf07c..1ee9be8 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -58,6 +58,7 @@ libimobiledevice_1_0_la_SOURCES = \
         companion_proxy.c companion_proxy.h \
         reverse_proxy.c reverse_proxy.h \
         syslog_relay.c syslog_relay.h \
+        ostrace.c ostrace.h \
         bt_packet_logger.c bt_packet_logger.h
 
 if WIN32
diff --git a/src/afc.c b/src/afc.c
index 1b4070b..e2e5ba1 100644
--- a/src/afc.c
+++ b/src/afc.c
@@ -26,9 +26,12 @@
 #endif
 #include <stdio.h>
 #include <stdlib.h>
-#include <unistd.h>
 #include <string.h>
 
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+
 #include "idevice.h"
 #include "afc.h"
 #include "common/debug.h"
@@ -56,6 +59,27 @@ static void afc_unlock(afc_client_t client)
         mutex_unlock(&client->mutex);
 }
 
+static afc_error_t service_to_afc_error(service_error_t err)
+{
+        switch (err) {
+                case SERVICE_E_SUCCESS:
+                        return AFC_E_SUCCESS;
+                case SERVICE_E_INVALID_ARG:
+                        return AFC_E_INVALID_ARG;
+                case SERVICE_E_MUX_ERROR:
+                        return AFC_E_MUX_ERROR;
+                case SERVICE_E_SSL_ERROR:
+                        return AFC_E_SSL_ERROR;
+                case SERVICE_E_NOT_ENOUGH_DATA:
+                        return AFC_E_NOT_ENOUGH_DATA;
+                case SERVICE_E_TIMEOUT:
+                        return AFC_E_OP_TIMEOUT;
+                default:
+                        break;
+        }
+        return AFC_E_UNKNOWN_ERROR;
+}
+
 /**
  * Makes a connection to the AFC service on the device using the given
  * connection.
@@ -115,7 +139,7 @@ afc_error_t afc_client_new(idevice_t device, lockdownd_service_descriptor_t serv
 
 afc_error_t afc_client_start_service(idevice_t device, afc_client_t * client, const char* label)
 {
-        afc_error_t err = AFC_E_UNKNOWN_ERROR;
+        int32_t err = AFC_E_UNKNOWN_ERROR;
         service_client_factory_start_service(device, AFC_SERVICE_NAME, (void**)client, label, SERVICE_CONSTRUCTOR(afc_client_new), &err);
         return err;
 }
@@ -171,11 +195,16 @@ static afc_error_t afc_dispatch_packet(afc_client_t client, uint64_t operation,
         AFCPacket_to_LE(client->afc_packet);
         debug_buffer((char*)client->afc_packet, sizeof(AFCPacket) + data_length);
         sent = 0;
-        service_send(client->parent, (void*)client->afc_packet, sizeof(AFCPacket) + data_length, &sent);
+        afc_error_t err = service_to_afc_error(service_send(client->parent, (void*)client->afc_packet, sizeof(AFCPacket) + data_length, &sent));
         AFCPacket_from_LE(client->afc_packet);
+        if (err != AFC_E_SUCCESS) {
+                debug_info("Failed to send packet (sent %i/%i): %s (%d)", sent, sizeof(AFCPacket) + data_length, afc_strerror(err), err);
+                return err;
+        }
         *bytes_sent += sent;
         if (sent < sizeof(AFCPacket) + data_length) {
-                return AFC_E_SUCCESS;
+                debug_info("Failed to send entire packet (sent %i/%i)", sent, sizeof(AFCPacket) + data_length);
+                return AFC_E_NOT_ENOUGH_DATA;
         }
 
         sent = 0;
@@ -187,11 +216,16 @@ static afc_error_t afc_dispatch_packet(afc_client_t client, uint64_t operation,
                         debug_info("packet payload follows");
                         debug_buffer(payload, payload_length);
                 }
-                service_send(client->parent, payload, payload_length, &sent);
+                err = service_to_afc_error(service_send(client->parent, payload, payload_length, &sent));
+                if (err != AFC_E_SUCCESS) {
+                        debug_info("Failed to send payload (sent: %i/%i): %s (%d)", sent, payload_length, afc_strerror(err), err);
+                        return err;
+                }
         }
         *bytes_sent += sent;
         if (sent < payload_length) {
-                return AFC_E_SUCCESS;
+                debug_info("Failed to send entire payload (sent: %i/%i): %s (%d)", sent, payload_length, afc_strerror(err), err);
+                return AFC_E_NOT_ENOUGH_DATA;
         }
 
         return AFC_E_SUCCESS;
@@ -224,21 +258,28 @@ static afc_error_t afc_receive_data(afc_client_t client, char **bytes, uint32_t
         }
 
         /* first, read the AFC header */
-        service_receive(client->parent, (char*)&header, sizeof(AFCPacket), &recv_len);
-        AFCPacket_from_LE(&header);
+        afc_error_t err = service_to_afc_error(service_receive(client->parent, (char*)&header, sizeof(AFCPacket), &recv_len));
+        if (err != AFC_E_SUCCESS) {
+                debug_info("Failed to receive AFC header: %s (%d)", afc_strerror(err), err);
+                return err;
+        }
         if (recv_len == 0) {
                 debug_info("Just didn't get enough.");
-                return AFC_E_MUX_ERROR;
+                return AFC_E_NOT_ENOUGH_DATA;
         }
 
         if (recv_len < sizeof(AFCPacket)) {
                 debug_info("Did not even get the AFCPacket header");
-                return AFC_E_MUX_ERROR;
+                return AFC_E_NOT_ENOUGH_DATA;
         }
 
+        /* make sure endianness is correct */
+        AFCPacket_from_LE(&header);
+
         /* check if it's a valid AFC header */
         if (strncmp(header.magic, AFC_MAGIC, AFC_MAGIC_LEN) != 0) {
                 debug_info("Invalid AFC packet received (magic != " AFC_MAGIC ")!");
+                return AFC_E_UNKNOWN_PACKET_TYPE;
         }
 
         /* check if it has the correct packet number */
@@ -270,16 +311,20 @@ static afc_error_t afc_receive_data(afc_client_t client, char **bytes, uint32_t
         buf = (char*)malloc(entire_len);
         if (this_len > 0) {
                 recv_len = 0;
-                service_receive(client->parent, buf, this_len, &recv_len);
+                err = service_to_afc_error(service_receive(client->parent, buf, this_len, &recv_len));
+                if (err != AFC_E_SUCCESS) {
+                        free(buf);
+                        debug_info("Failed to receive data: %s (%d)", afc_strerror(err), err);
+                }
                 if (recv_len <= 0) {
                         free(buf);
                         debug_info("Did not get packet contents!");
-                        return AFC_E_NOT_ENOUGH_DATA;
+                        return (err == AFC_E_SUCCESS) ? AFC_E_NOT_ENOUGH_DATA : err;
                 }
                 if (recv_len < this_len) {
                         free(buf);
                         debug_info("Could not receive this_len=%d bytes", this_len);
-                        return AFC_E_NOT_ENOUGH_DATA;
+                        return (err == AFC_E_SUCCESS) ? AFC_E_END_OF_DATA : err;
                 }
         }
 
@@ -288,7 +333,11 @@ static afc_error_t afc_receive_data(afc_client_t client, char **bytes, uint32_t
         if (entire_len > this_len) {
                 while (current_count < entire_len) {
                         recv_len = 0;
-                        service_receive(client->parent, buf+current_count, entire_len - current_count, &recv_len);
+                        err = service_to_afc_error(service_receive(client->parent, buf+current_count, entire_len - current_count, &recv_len));
+                        if (err != AFC_E_SUCCESS) {
+                                debug_info("Error receiving data: %s (%d)", afc_strerror(err), err);
+                                break;
+                        }
                         if (recv_len <= 0) {
                                 debug_info("Error receiving data (recv returned %d)", recv_len);
                                 break;
@@ -296,7 +345,9 @@ static afc_error_t afc_receive_data(afc_client_t client, char **bytes, uint32_t
                         current_count += recv_len;
                 }
                 if (current_count < entire_len) {
-                        debug_info("WARNING: could not receive full packet (read %s, size %d)", current_count, entire_len);
+                        free(buf);
+                        debug_info("ERROR: Could not receive entire packet (read %i/%i)", current_count, entire_len);
+                        return (err == AFC_E_SUCCESS) ? AFC_E_END_OF_DATA : err;
                 }
         }
 
@@ -338,7 +389,7 @@ static afc_error_t afc_receive_data(afc_client_t client, char **bytes, uint32_t
                 free(buf);
 
                 debug_info("WARNING: Unknown operation code received 0x%llx param1=%lld", header.operation, param1);
-#ifndef WIN32
+#ifndef _WIN32
                 fprintf(stderr, "%s: WARNING: Unknown operation code received 0x%llx param1=%lld", __func__, (long long)header.operation, (long long)param1);
 #endif
 
@@ -399,6 +450,50 @@ static char **make_strings_list(char *tokens, uint32_t length)
         return list;
 }
 
+static plist_t *make_dictionary(char *tokens, size_t length)
+{
+        size_t j = 0;
+        plist_t dict = NULL;
+
+        if (!tokens || !length)
+                return NULL;
+
+        dict = plist_new_dict();
+
+        while (j < length) {
+                size_t key_len = strnlen(tokens + j, length - j);
+                if (j + key_len >= length) {
+                        plist_free(dict);
+                        return NULL;
+                }
+                char* key = tokens + j;
+                j += key_len + 1;
+
+                if (j >= length) {
+                        plist_free(dict);
+                        return NULL;
+                }
+
+                size_t val_len = strnlen(tokens + j, length - j);
+                if (j + val_len >= length) {
+                        plist_free(dict);
+                        return NULL;
+                }
+                char* val = tokens + j;
+                j += val_len + 1;
+
+                char* endp = NULL;
+                unsigned long long u64val = strtoull(val, &endp, 10);
+                if (endp && *endp == '\0') {
+                        plist_dict_set_item(dict, key, plist_new_uint(u64val));
+                } else {
+                        plist_dict_set_item(dict, key, plist_new_string(val));
+                }
+        }
+
+        return dict;
+}
+
 static int _afc_check_packet_buffer(afc_client_t client, uint32_t data_len)
 {
         if (data_len > client->packet_extra) {
@@ -495,6 +590,40 @@ afc_error_t afc_get_device_info(afc_client_t client, char ***device_information)
         return ret;
 }
 
+afc_error_t afc_get_device_info_plist(afc_client_t client, plist_t *device_information)
+{
+        uint32_t bytes = 0;
+        char *data = NULL;
+        afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+        if (!client || !device_information)
+                return AFC_E_INVALID_ARG;
+
+        afc_lock(client);
+
+        /* Send the command */
+        ret = afc_dispatch_packet(client, AFC_OP_GET_DEVINFO, 0, NULL, 0, &bytes);
+        if (ret != AFC_E_SUCCESS) {
+                afc_unlock(client);
+                return AFC_E_NOT_ENOUGH_DATA;
+        }
+        /* Receive the data */
+        ret = afc_receive_data(client, &data, &bytes);
+        if (ret != AFC_E_SUCCESS) {
+                if (data)
+                        free(data);
+                afc_unlock(client);
+                return ret;
+        }
+        /* Parse the data */
+        *device_information = make_dictionary(data, bytes);
+        free(data);
+
+        afc_unlock(client);
+
+        return ret;
+}
+
 afc_error_t afc_get_device_info_key(afc_client_t client, const char *key, char **value)
 {
         afc_error_t ret = AFC_E_INTERNAL_ERROR;
@@ -644,8 +773,6 @@ afc_error_t afc_get_file_info(afc_client_t client, const char *path, char ***fil
                 return AFC_E_NO_MEM;
         }
 
-        debug_info("We got %p and %p", client->afc_packet, AFC_PACKET_DATA_PTR);
-
         /* Send command */
         memcpy(AFC_PACKET_DATA_PTR, path, data_len);
         ret = afc_dispatch_packet(client, AFC_OP_GET_FILE_INFO, data_len, NULL, 0, &bytes);
@@ -666,6 +793,44 @@ afc_error_t afc_get_file_info(afc_client_t client, const char *path, char ***fil
         return ret;
 }
 
+afc_error_t afc_get_file_info_plist(afc_client_t client, const char *path, plist_t *file_information)
+{
+        char *received = NULL;
+        uint32_t bytes = 0;
+        afc_error_t ret = AFC_E_UNKNOWN_ERROR;
+
+        if (!client || !path || !file_information)
+                return AFC_E_INVALID_ARG;
+
+        afc_lock(client);
+
+        uint32_t data_len = (uint32_t)strlen(path)+1;
+        if (_afc_check_packet_buffer(client, data_len) < 0) {
+                afc_unlock(client);
+                debug_info("Failed to realloc packet buffer");
+                return AFC_E_NO_MEM;
+        }
+
+        /* Send command */
+        memcpy(AFC_PACKET_DATA_PTR, path, data_len);
+        ret = afc_dispatch_packet(client, AFC_OP_GET_FILE_INFO, data_len, NULL, 0, &bytes);
+        if (ret != AFC_E_SUCCESS) {
+                afc_unlock(client);
+                return AFC_E_NOT_ENOUGH_DATA;
+        }
+
+        /* Receive data */
+        ret = afc_receive_data(client, &received, &bytes);
+        if (received) {
+                *file_information = make_dictionary(received, bytes);
+                free(received);
+        }
+
+        afc_unlock(client);
+
+        return ret;
+}
+
 afc_error_t afc_file_open(afc_client_t client, const char *filename, afc_file_mode_t file_mode, uint64_t *handle)
 {
         if (!client || !client->parent || !client->afc_packet)
@@ -1182,14 +1347,14 @@ const char* afc_strerror(afc_error_t err)
                         return "Internal error";
                 case AFC_E_MUX_ERROR:
                         return "MUX error";
+                case AFC_E_SSL_ERROR:
+                        return "SSL error";
                 case AFC_E_NO_MEM:
                         return "Out of memory";
                 case AFC_E_NOT_ENOUGH_DATA:
                         return "Not enough data";
                 case AFC_E_DIR_NOT_EMPTY:
                         return "Directory not empty";
-                case AFC_E_FORCE_SIGNED_TYPE:
-                        return "Force signed type";
                 default:
                         break;
         }
diff --git a/src/house_arrest.c b/src/house_arrest.c
index caad731..06068c6 100644
--- a/src/house_arrest.c
+++ b/src/house_arrest.c
@@ -24,7 +24,11 @@
 #endif
 #include <string.h>
 #include <stdlib.h>
+
+#ifndef _MSC_VER
 #include <unistd.h>
+#endif
+
 #include <plist/plist.h>
 
 #include "house_arrest.h"
diff --git a/src/idevice.c b/src/idevice.c
index b9bbb1f..0af27fd 100644
--- a/src/idevice.c
+++ b/src/idevice.c
@@ -30,7 +30,7 @@
 #include <errno.h>
 #include <time.h>
 
-#ifdef WIN32
+#ifdef _WIN32
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #include <windows.h>
@@ -124,32 +124,32 @@ static void id_function(CRYPTO_THREADID *thread)
 #endif
 #endif /* HAVE_OPENSSL */
 
-static void internal_idevice_init(void)
-{
-#if defined(HAVE_OPENSSL)
-#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
-        int i;
-        SSL_library_init();
-
-        mutex_buf = malloc(CRYPTO_num_locks() * sizeof(mutex_t));
-        if (!mutex_buf)
-                return;
-        for (i = 0; i < CRYPTO_num_locks(); i++)
-                mutex_init(&mutex_buf[i]);
-
-#if OPENSSL_VERSION_NUMBER < 0x10000000L
-        CRYPTO_set_id_callback(id_function);
+// Reference: https://stackoverflow.com/a/2390626/1806760
+// Initializer/finalizer sample for MSVC and GCC/Clang.
+// 2010-2016 Joe Lowe. Released into the public domain.
+
+#ifdef __cplusplus
+    #define INITIALIZER(f) \
+        static void f(void); \
+        struct f##_t_ { f##_t_(void) { f(); } }; static f##_t_ f##_; \
+        static void f(void)
+#elif defined(_MSC_VER)
+    #pragma section(".CRT$XCU",read)
+    #define INITIALIZER2_(f,p) \
+        static void f(void); \
+        __declspec(allocate(".CRT$XCU")) void (*f##_)(void) = f; \
+        __pragma(comment(linker,"/include:" p #f "_")) \
+        static void f(void)
+    #ifdef _WIN64
+        #define INITIALIZER(f) INITIALIZER2_(f,"")
+    #else
+        #define INITIALIZER(f) INITIALIZER2_(f,"_")
+    #endif
 #else
-        CRYPTO_THREADID_set_callback(id_function);
-#endif
-        CRYPTO_set_locking_callback(locking_function);
-#endif
-#elif defined(HAVE_GNUTLS)
-        gnutls_global_init();
-#elif defined(HAVE_MBEDTLS)
-        // NO-OP
+    #define INITIALIZER(f) \
+        static void f(void) __attribute__((__constructor__)); \
+        static void f(void)
 #endif
-}
 
 static void internal_idevice_deinit(void)
 {
@@ -181,43 +181,33 @@ static void internal_idevice_deinit(void)
 #endif
 }
 
-static thread_once_t init_once = THREAD_ONCE_INIT;
-static thread_once_t deinit_once = THREAD_ONCE_INIT;
-
-#ifndef HAVE_ATTRIBUTE_CONSTRUCTOR
-  #if defined(__llvm__) || defined(__GNUC__)
-    #define HAVE_ATTRIBUTE_CONSTRUCTOR
-  #endif
-#endif
-
-#ifdef HAVE_ATTRIBUTE_CONSTRUCTOR
-static void __attribute__((constructor)) libimobiledevice_initialize(void)
+INITIALIZER(internal_idevice_init)
 {
-        thread_once(&init_once, internal_idevice_init);
-}
+#if defined(HAVE_OPENSSL)
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
+        int i;
+        SSL_library_init();
 
-static void __attribute__((destructor)) libimobiledevice_deinitialize(void)
-{
-        thread_once(&deinit_once, internal_idevice_deinit);
-}
-#elif defined(WIN32)
-BOOL WINAPI DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpReserved)
-{
-        switch (dwReason) {
-        case DLL_PROCESS_ATTACH:
-                thread_once(&init_once, internal_idevice_init);
-                break;
-        case DLL_PROCESS_DETACH:
-                thread_once(&deinit_once, internal_idevice_deinit);
-                break;
-        default:
-                break;
-        }
-        return 1;
-}
+        mutex_buf = malloc(CRYPTO_num_locks() * sizeof(mutex_t));
+        if (!mutex_buf)
+                return;
+        for (i = 0; i < CRYPTO_num_locks(); i++)
+                mutex_init(&mutex_buf[i]);
+
+#if OPENSSL_VERSION_NUMBER < 0x10000000L
+        CRYPTO_set_id_callback(id_function);
 #else
-#warning No compiler support for constructor/destructor attributes, some features might not be available.
+        CRYPTO_THREADID_set_callback(id_function);
+#endif
+        CRYPTO_set_locking_callback(locking_function);
+#endif
+#elif defined(HAVE_GNUTLS)
+        gnutls_global_init();
+#elif defined(HAVE_MBEDTLS)
+        // NO-OP
 #endif
+        atexit(internal_idevice_deinit);
+}
 
 const char* libimobiledevice_version()
 {
@@ -548,7 +538,7 @@ idevice_error_t idevice_connect(idevice_t device, uint16_t port, idevice_connect
                 }
                 idevice_connection_t new_connection = (idevice_connection_t)malloc(sizeof(struct idevice_connection_private));
                 new_connection->type = CONNECTION_USBMUXD;
-                new_connection->data = (void*)(long)sfd;
+                new_connection->data = (void*)(uintptr_t)sfd;
                 new_connection->ssl_data = NULL;
                 new_connection->device = device;
                 new_connection->ssl_recv_timeout = (unsigned int)-1;
@@ -593,7 +583,7 @@ idevice_error_t idevice_connect(idevice_t device, uint16_t port, idevice_connect
 
                 idevice_connection_t new_connection = (idevice_connection_t)malloc(sizeof(struct idevice_connection_private));
                 new_connection->type = CONNECTION_NETWORK;
-                new_connection->data = (void*)(long)sfd;
+                new_connection->data = (void*)(uintptr_t)sfd;
                 new_connection->ssl_data = NULL;
                 new_connection->device = device;
                 new_connection->ssl_recv_timeout = (unsigned int)-1;
@@ -618,11 +608,11 @@ idevice_error_t idevice_disconnect(idevice_connection_t connection)
         }
         idevice_error_t result = IDEVICE_E_UNKNOWN_ERROR;
         if (connection->type == CONNECTION_USBMUXD) {
-                usbmuxd_disconnect((int)(long)connection->data);
+                usbmuxd_disconnect((int)(uintptr_t)connection->data);
                 connection->data = NULL;
                 result = IDEVICE_E_SUCCESS;
         } else if (connection->type == CONNECTION_NETWORK) {
-                socket_close((int)(long)connection->data);
+                socket_close((int)(uintptr_t)connection->data);
                 connection->data = NULL;
                 result = IDEVICE_E_SUCCESS;
         } else {
@@ -647,7 +637,7 @@ static idevice_error_t internal_connection_send(idevice_connection_t connection,
         if (connection->type == CONNECTION_USBMUXD) {
                 int res;
                 do {
-                        res = usbmuxd_send((int)(long)connection->data, data, len, sent_bytes);
+                        res = usbmuxd_send((int)(uintptr_t)connection->data, data, len, sent_bytes);
                 } while (res == -EAGAIN);
                 if (res < 0) {
                         debug_info("ERROR: usbmuxd_send returned %d (%s)", res, strerror(-res));
@@ -656,7 +646,7 @@ static idevice_error_t internal_connection_send(idevice_connection_t connection,
                 return IDEVICE_E_SUCCESS;
         }
         if (connection->type == CONNECTION_NETWORK) {
-                int s = socket_send((int)(long)connection->data, (void*)data, len);
+                int s = socket_send((int)(uintptr_t)connection->data, (void*)data, len);
                 if (s < 0) {
                         *sent_bytes = 0;
                         return IDEVICE_E_UNKNOWN_ERROR;
@@ -763,7 +753,7 @@ static idevice_error_t internal_connection_receive_timeout(idevice_connection_t
         }
 
         if (connection->type == CONNECTION_USBMUXD) {
-                int conn_error = usbmuxd_recv_timeout((int)(long)connection->data, data, len, recv_bytes, timeout);
+                int conn_error = usbmuxd_recv_timeout((int)(uintptr_t)connection->data, data, len, recv_bytes, timeout);
                 idevice_error_t error = socket_recv_to_idevice_error(conn_error, len, *recv_bytes);
                 if (error == IDEVICE_E_UNKNOWN_ERROR) {
                         debug_info("ERROR: usbmuxd_recv_timeout returned %d (%s)", conn_error, strerror(-conn_error));
@@ -771,7 +761,7 @@ static idevice_error_t internal_connection_receive_timeout(idevice_connection_t
                 return error;
         }
         if (connection->type == CONNECTION_NETWORK) {
-                int res = socket_receive_timeout((int)(long)connection->data, data, len, 0, timeout);
+                int res = socket_receive_timeout((int)(uintptr_t)connection->data, data, len, 0, timeout);
                 idevice_error_t error = socket_recv_to_idevice_error(res, 0, 0);
                 if (error == IDEVICE_E_SUCCESS) {
                         *recv_bytes = (uint32_t)res;
@@ -863,7 +853,7 @@ static idevice_error_t internal_connection_receive(idevice_connection_t connecti
         }
 
         if (connection->type == CONNECTION_USBMUXD) {
-                int res = usbmuxd_recv((int)(long)connection->data, data, len, recv_bytes);
+                int res = usbmuxd_recv((int)(uintptr_t)connection->data, data, len, recv_bytes);
                 if (res < 0) {
                         debug_info("ERROR: usbmuxd_recv returned %d (%s)", res, strerror(-res));
                         return IDEVICE_E_UNKNOWN_ERROR;
@@ -871,7 +861,7 @@ static idevice_error_t internal_connection_receive(idevice_connection_t connecti
                 return IDEVICE_E_SUCCESS;
         }
         if (connection->type == CONNECTION_NETWORK) {
-                int res = socket_receive((int)(long)connection->data, data, len);
+                int res = socket_receive((int)(uintptr_t)connection->data, data, len);
                 if (res < 0) {
                         debug_info("ERROR: socket_receive returned %d (%s)", res, strerror(-res));
                         return IDEVICE_E_UNKNOWN_ERROR;
@@ -924,11 +914,11 @@ idevice_error_t idevice_connection_get_fd(idevice_connection_t connection, int *
         }
 
         if (connection->type == CONNECTION_USBMUXD) {
-                *fd = (int)(long)connection->data;
+                *fd = (int)(uintptr_t)connection->data;
                 return IDEVICE_E_SUCCESS;
         }
         if (connection->type == CONNECTION_NETWORK) {
-                *fd = (int)(long)connection->data;
+                *fd = (int)(uintptr_t)connection->data;
                 return IDEVICE_E_SUCCESS;
         }
 
@@ -956,6 +946,20 @@ idevice_error_t idevice_get_udid(idevice_t device, char **udid)
         return IDEVICE_E_SUCCESS;
 }
 
+unsigned int idevice_get_device_version(idevice_t device)
+{
+        if (!device) {
+                return 0;
+        }
+        if (!device->version) {
+                lockdownd_client_t lockdown = NULL;
+                lockdownd_client_new(device, &lockdown, NULL);
+                // we don't handle any errors here. We should have the product version cached now.
+                lockdownd_client_free(lockdown);
+        }
+        return device->version;
+}
+
 #if defined(HAVE_OPENSSL) || defined(HAVE_GNUTLS)
 typedef ssize_t ssl_cb_ret_type_t;
 #elif defined(HAVE_MBEDTLS)
@@ -1075,13 +1079,14 @@ static long ssl_idevice_bio_callback(BIO *b, int oper, const char *argp, int arg
         idevice_connection_t conn = (idevice_connection_t)BIO_get_callback_arg(b);
 #if OPENSSL_VERSION_NUMBER < 0x30000000L
         size_t len = (size_t)argi;
-        size_t *processed = (size_t*)&bytes;
 #endif
         switch (oper) {
         case (BIO_CB_READ|BIO_CB_RETURN):
                 if (argp) {
                         bytes = internal_ssl_read(conn, (char *)argp, len);
-                        *processed = bytes;
+#if OPENSSL_VERSION_NUMBER >= 0x30000000L
+                        *processed = (size_t)(bytes < 0) ? 0 : bytes;
+#endif
                         return (long)bytes;
                 }
                 return 0;
@@ -1090,7 +1095,9 @@ static long ssl_idevice_bio_callback(BIO *b, int oper, const char *argp, int arg
                 // fallthrough
         case (BIO_CB_WRITE|BIO_CB_RETURN):
                 bytes = internal_ssl_write(conn, argp, len);
-                *processed = bytes;
+#if OPENSSL_VERSION_NUMBER >= 0x30000000L
+                *processed = (size_t)(bytes < 0) ? 0 : bytes;
+#endif
                 return (long)bytes;
         default:
                 return retvalue;
@@ -1239,7 +1246,7 @@ idevice_error_t idevice_connection_enable_ssl(idevice_connection_t connection)
 #if OPENSSL_VERSION_NUMBER < 0x10100002L || \
         (defined(LIBRESSL_VERSION_NUMBER) && (LIBRESSL_VERSION_NUMBER < 0x2060000fL))
         /* force use of TLSv1 for older devices */
-        if (connection->device->version < DEVICE_VERSION(10,0,0)) {
+        if (connection->device->version < IDEVICE_DEVICE_VERSION(10,0,0)) {
 #ifdef SSL_OP_NO_TLSv1_1
                 SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_TLSv1_1);
 #endif
@@ -1252,7 +1259,7 @@ idevice_error_t idevice_connection_enable_ssl(idevice_connection_t connection)
         }
 #else
         SSL_CTX_set_min_proto_version(ssl_ctx, TLS1_VERSION);
-        if (connection->device->version < DEVICE_VERSION(10,0,0)) {
+        if (connection->device->version < IDEVICE_DEVICE_VERSION(10,0,0)) {
                 SSL_CTX_set_max_proto_version(ssl_ctx, TLS1_VERSION);
                 if (connection->device->version == 0) {
                         /*
@@ -1338,7 +1345,7 @@ idevice_error_t idevice_connection_enable_ssl(idevice_connection_t connection)
                 if (ssl_error == 0 || ssl_error != SSL_ERROR_WANT_READ) {
                         break;
                 }
-#ifdef WIN32
+#ifdef _WIN32
                 Sleep(100);
 #else
                 struct timespec ts = { 0, 100000000 };
@@ -1544,3 +1551,28 @@ idevice_error_t idevice_connection_disable_bypass_ssl(idevice_connection_t conne
 
         return IDEVICE_E_SUCCESS;
 }
+
+const char* idevice_strerror(idevice_error_t err)
+{
+        switch (err) {
+                case IDEVICE_E_SUCCESS:
+                        return "Success";
+                case IDEVICE_E_INVALID_ARG:
+                        return "Invalid argument";
+                case IDEVICE_E_UNKNOWN_ERROR:
+                        return "Unknown Error";
+                case IDEVICE_E_NO_DEVICE:
+                        return "No device";
+                case IDEVICE_E_NOT_ENOUGH_DATA:
+                        return "Not enough data";
+                case IDEVICE_E_CONNREFUSED:
+                        return "Connection refused";
+                case IDEVICE_E_SSL_ERROR:
+                        return "SSL error";
+                case IDEVICE_E_TIMEOUT:
+                        return "Timeout";
+                default:
+                        break;
+        }
+        return "Unknown Error";
+}
diff --git a/src/idevice.h b/src/idevice.h
index dd72f9d..e05338e 100644
--- a/src/idevice.h
+++ b/src/idevice.h
@@ -52,8 +52,6 @@
 #include "common/userpref.h"
 #include "libimobiledevice/libimobiledevice.h"
 
-#define DEVICE_VERSION(maj, min, patch) (((maj & 0xFF) << 16) | ((min & 0xFF) << 8) | (patch & 0xFF))
-
 #define DEVICE_CLASS_IPHONE  1
 #define DEVICE_CLASS_IPAD    2
 #define DEVICE_CLASS_IPOD    3
diff --git a/src/installation_proxy.c b/src/installation_proxy.c
index ec19da0..bb6ef01 100644
--- a/src/installation_proxy.c
+++ b/src/installation_proxy.c
@@ -26,7 +26,11 @@
 #include <string.h>
 #include <stdlib.h>
 #include <inttypes.h>
+
+#ifndef _MSC_VER
 #include <unistd.h>
+#endif
+
 #include <plist/plist.h>
 
 #include "installation_proxy.h"
@@ -251,7 +255,7 @@ instproxy_error_t instproxy_client_new(idevice_t device, lockdownd_service_descr
 
 instproxy_error_t instproxy_client_start_service(idevice_t device, instproxy_client_t * client, const char* label)
 {
-        instproxy_error_t err = INSTPROXY_E_UNKNOWN_ERROR;
+        int32_t err = INSTPROXY_E_UNKNOWN_ERROR;
         service_client_factory_start_service(device, INSTPROXY_SERVICE_NAME, (void**)client, label, SERVICE_CONSTRUCTOR(instproxy_client_new), &err);
         return err;
 }
diff --git a/src/lockdown-cu.c b/src/lockdown-cu.c
index 1afc2c5..c457cb2 100644
--- a/src/lockdown-cu.c
+++ b/src/lockdown-cu.c
@@ -29,7 +29,11 @@
 #define __USE_GNU 1
 #include <stdio.h>
 #include <ctype.h>
+
+#ifndef _MSC_VER
 #include <unistd.h>
+#endif
+
 #include <plist/plist.h>
 
 #include "idevice.h"
@@ -505,7 +509,7 @@ lockdownd_error_t lockdownd_cu_pairing_create(lockdownd_client_t client, lockdow
                         char *s_version = NULL;
                         plist_get_string_val(p_version, &s_version);
                         if (s_version && sscanf(s_version, "%d.%d.%d", &vers[0], &vers[1], &vers[2]) >= 2) {
-                                client->device->version = DEVICE_VERSION(vers[0], vers[1], vers[2]);
+                                client->device->version = IDEVICE_DEVICE_VERSION(vers[0], vers[1], vers[2]);
                         }
                         free(s_version);
                 }
@@ -653,7 +657,7 @@ lockdownd_error_t lockdownd_cu_pairing_create(lockdownd_client_t client, lockdow
                         CFStringGetCString(cname, hostname, sizeof(hostname), kCFStringEncodingUTF8);
                         CFRelease(cname);
 #else
-#ifdef WIN32
+#ifdef _WIN32
                         DWORD hostname_len = sizeof(hostname);
                         GetComputerName(hostname, &hostname_len);
 #else
@@ -957,12 +961,12 @@ lockdownd_error_t lockdownd_cu_send_request_and_get_reply(lockdownd_client_t cli
         hkdf_md(MD_ALGO_SHA512, (unsigned char*)READ_KEY_SALT_MDLD, sizeof(READ_KEY_SALT_MDLD)-1, (unsigned char*)READ_KEY_INFO_MDLD, sizeof(READ_KEY_INFO_MDLD)-1, client->cu_key, client->cu_key_len, cu_read_key, &cu_read_key_len);
 
         // Starting with iOS/tvOS 11.2 and WatchOS 4.2, this nonce is random and sent along with the request. Before, the request doesn't have a nonce and it uses hardcoded nonce "sendone01234".
-        unsigned char cu_nonce[12] = "sendone01234"; // guaranteed to be random by fair dice troll
-        if (client->device->version >= DEVICE_VERSION(11,2,0)) {
+        unsigned char cu_nonce[] = "sendone01234"; // guaranteed to be random by fair dice troll
+        if (client->device->version >= IDEVICE_DEVICE_VERSION(11,2,0)) {
 #if defined(HAVE_OPENSSL)
-                RAND_bytes(cu_nonce, sizeof(cu_nonce));
+                RAND_bytes(cu_nonce, sizeof(cu_nonce)-1);
 #elif defined(HAVE_GCRYPT)
-                gcry_create_nonce(cu_nonce, sizeof(cu_nonce));
+                gcry_create_nonce(cu_nonce, sizeof(cu_nonce)-1);
 #endif
         }
 
@@ -1128,7 +1132,7 @@ lockdownd_error_t lockdownd_pair_cu(lockdownd_client_t client)
         plist_free(pubkey);     
 
         plist_t pair_record_plist = plist_new_dict();
-        pair_record_generate_keys_and_certs(pair_record_plist, public_key);
+        pair_record_generate_keys_and_certs(pair_record_plist, public_key, client->device->version);
 
         char* host_id = NULL;
         char* system_buid = NULL;
diff --git a/src/lockdown.c b/src/lockdown.c
index 256bff0..32389c9 100644
--- a/src/lockdown.c
+++ b/src/lockdown.c
@@ -32,7 +32,11 @@
 #define __USE_GNU 1
 #include <stdio.h>
 #include <ctype.h>
+
+#ifndef _MSC_VER
 #include <unistd.h>
+#endif
+
 #include <plist/plist.h>
 #include <libimobiledevice-glue/utils.h>
 
@@ -43,7 +47,7 @@
 #include "common/userpref.h"
 #include "asprintf.h"
 
-#ifdef WIN32
+#ifdef _WIN32
 #include <windows.h>
 #define sleep(x) Sleep(x*1000)
 #endif
@@ -617,6 +621,7 @@ lockdownd_error_t lockdownd_client_new(idevice_t device, lockdownd_client_t *cli
                 .port = 0xf27e,
                 .ssl_enabled = 0
         };
+        char *type = NULL;
 
         property_list_service_client_t plistclient = NULL;
         if (property_list_service_client_new(device, (lockdownd_service_descriptor_t)&service, &plistclient) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
@@ -638,51 +643,32 @@ lockdownd_error_t lockdownd_client_new(idevice_t device, lockdownd_client_t *cli
 
         client_loc->label = label ? strdup(label) : NULL;
 
-        *client = client_loc;
-
-        return LOCKDOWN_E_SUCCESS;
-}
-
-lockdownd_error_t lockdownd_client_new_with_handshake(idevice_t device, lockdownd_client_t *client, const char *label)
-{
-        if (!client)
-                return LOCKDOWN_E_INVALID_ARG;
-
-        lockdownd_error_t ret = LOCKDOWN_E_SUCCESS;
-        lockdownd_client_t client_loc = NULL;
-        plist_t pair_record = NULL;
-        char *host_id = NULL;
-        char *type = NULL;
-
-        ret = lockdownd_client_new(device, &client_loc, label);
-        if (LOCKDOWN_E_SUCCESS != ret) {
-                debug_info("failed to create lockdownd client.");
-                return ret;
-        }
-
-        /* perform handshake */
-        ret = lockdownd_query_type(client_loc, &type);
-        if (LOCKDOWN_E_SUCCESS != ret) {
+        int is_lockdownd = 0;
+        if (lockdownd_query_type(client_loc, &type) != LOCKDOWN_E_SUCCESS) {
                 debug_info("QueryType failed in the lockdownd client.");
-        } else if (strcmp("com.apple.mobile.lockdown", type) != 0) {
-                debug_info("Warning QueryType request returned \"%s\".", type);
+        } else if (!strcmp("com.apple.mobile.lockdown", type)) {
+                is_lockdownd = 1;
+        } else {
+                debug_info("QueryType request returned \"%s\"", type);
         }
         free(type);
 
-        if (device->version == 0) {
+        *client = client_loc;
+
+        if (is_lockdownd && device->version == 0) {
                 plist_t p_version = NULL;
                 if (lockdownd_get_value(client_loc, NULL, "ProductVersion", &p_version) == LOCKDOWN_E_SUCCESS) {
                         int vers[3] = {0, 0, 0};
                         char *s_version = NULL;
                         plist_get_string_val(p_version, &s_version);
                         if (s_version && sscanf(s_version, "%d.%d.%d", &vers[0], &vers[1], &vers[2]) >= 2) {
-                                device->version = DEVICE_VERSION(vers[0], vers[1], vers[2]);
+                                device->version = IDEVICE_DEVICE_VERSION(vers[0], vers[1], vers[2]);
                         }
                         free(s_version);
                 }
                 plist_free(p_version);
         }
-        if (device->device_class == 0) {
+        if (is_lockdownd && device->device_class == 0) {
                 plist_t p_device_class = NULL;
                 if (lockdownd_get_value(client_loc, NULL, "DeviceClass", &p_device_class) == LOCKDOWN_E_SUCCESS) {
                         char* s_device_class = NULL;
@@ -707,6 +693,26 @@ lockdownd_error_t lockdownd_client_new_with_handshake(idevice_t device, lockdown
                 plist_free(p_device_class);
         }
 
+        return LOCKDOWN_E_SUCCESS;
+}
+
+lockdownd_error_t lockdownd_client_new_with_handshake(idevice_t device, lockdownd_client_t *client, const char *label)
+{
+        if (!client)
+                return LOCKDOWN_E_INVALID_ARG;
+
+        lockdownd_error_t ret = LOCKDOWN_E_SUCCESS;
+        lockdownd_client_t client_loc = NULL;
+        plist_t pair_record = NULL;
+        char *host_id = NULL;
+
+        ret = lockdownd_client_new(device, &client_loc, label);
+        if (LOCKDOWN_E_SUCCESS != ret) {
+                debug_info("failed to create lockdownd client.");
+                return ret;
+        }
+
+        /* perform handshake */
         userpref_error_t uerr = userpref_read_pair_record(client_loc->device->udid, &pair_record);
         if (uerr == USERPREF_E_READ_ERROR) {
                 debug_info("ERROR: Failed to retrieve pair record for %s", client_loc->device->udid);
@@ -730,7 +736,7 @@ lockdownd_error_t lockdownd_client_new_with_handshake(idevice_t device, lockdown
         plist_free(pair_record);
         pair_record = NULL;
 
-        if (device->version < DEVICE_VERSION(7,0,0) && device->device_class != DEVICE_CLASS_WATCH) {
+        if (device->version < IDEVICE_DEVICE_VERSION(7,0,0) && device->device_class != DEVICE_CLASS_WATCH) {
                 /* for older devices, we need to validate pairing to receive trusted host status */
                 ret = lockdownd_validate_pair(client_loc, NULL);
 
@@ -836,7 +842,7 @@ static lockdownd_error_t pair_record_generate(lockdownd_client_t client, plist_t
 
         /* generate keys and certificates into pair record */
         userpref_error_t uret = USERPREF_E_SUCCESS;
-        uret = pair_record_generate_keys_and_certs(*pair_record, public_key);
+        uret = pair_record_generate_keys_and_certs(*pair_record, public_key, client->device->version);
         switch(uret) {
                 case USERPREF_E_INVALID_ARG:
                         ret = LOCKDOWN_E_INVALID_ARG;
@@ -846,6 +852,7 @@ static lockdownd_error_t pair_record_generate(lockdownd_client_t client, plist_t
                         break;
                 case USERPREF_E_SSL_ERROR:
                         ret = LOCKDOWN_E_SSL_ERROR;
+                        break;
                 default:
                         break;
         }
diff --git a/src/misagent.c b/src/misagent.c
index e3da997..3fdca4d 100644
--- a/src/misagent.c
+++ b/src/misagent.c
@@ -24,9 +24,13 @@
 #endif
 #include <string.h>
 #include <stdlib.h>
+#include <stdio.h>
+
+#ifndef _MSC_VER
 #include <unistd.h>
+#endif
+
 #include <plist/plist.h>
-#include <stdio.h>
 
 #include "misagent.h"
 #include "property_list_service.h"
diff --git a/src/mobile_image_mounter.c b/src/mobile_image_mounter.c
index 6df50c4..6677882 100644
--- a/src/mobile_image_mounter.c
+++ b/src/mobile_image_mounter.c
@@ -24,7 +24,11 @@
 #endif
 #include <string.h>
 #include <stdlib.h>
+
+#ifndef _MSC_VER
 #include <unistd.h>
+#endif
+
 #include <plist/plist.h>
 
 #include "mobile_image_mounter.h"
diff --git a/src/notification_proxy.c b/src/notification_proxy.c
index 60b2e03..c7e4660 100644
--- a/src/notification_proxy.c
+++ b/src/notification_proxy.c
@@ -24,14 +24,19 @@
 #endif
 #include <string.h>
 #include <stdlib.h>
+
+#ifndef _MSC_VER
 #include <unistd.h>
+#endif
+
 #include <plist/plist.h>
 
 #include "notification_proxy.h"
 #include "property_list_service.h"
 #include "common/debug.h"
 
-#ifdef WIN32
+#ifdef _WIN32
+#include <windows.h>
 #define sleep(x) Sleep(x*1000)
 #endif
 
@@ -109,7 +114,7 @@ np_error_t np_client_new(idevice_t device, lockdownd_service_descriptor_t servic
 
 np_error_t np_client_start_service(idevice_t device, np_client_t* client, const char* label)
 {
-        np_error_t err = NP_E_UNKNOWN_ERROR;
+        int32_t err = NP_E_UNKNOWN_ERROR;
         service_client_factory_start_service(device, NP_SERVICE_NAME, (void**)client, label, SERVICE_CONSTRUCTOR(np_client_new), &err);
         return err;
 }
diff --git a/src/ostrace.c b/src/ostrace.c
new file mode 100644
index 0000000..68eb6bf
--- /dev/null
+++ b/src/ostrace.c
@@ -0,0 +1,436 @@
+/*
+ * ostrace.c
+ * com.apple.os_trace_relay service implementation.
+ *
+ * Copyright (c) 2020-2025 Nikias Bassen, All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <string.h>
+#include <stdlib.h>
+
+#include <plist/plist.h>
+
+#include "ostrace.h"
+#include "lockdown.h"
+#include "common/debug.h"
+#include "endianness.h"
+
+struct ostrace_worker_thread {
+        ostrace_client_t client;
+        ostrace_activity_cb_t cbfunc;
+        void *user_data;
+};
+
+/**
+ * Convert a service_error_t value to a ostrace_error_t value.
+ * Used internally to get correct error codes.
+ *
+ * @param err An service_error_t error code
+ *
+ * @return A matching ostrace_error_t error code,
+ *     OSTRACE_E_UNKNOWN_ERROR otherwise.
+ */
+static ostrace_error_t ostrace_error(service_error_t err)
+{
+        switch (err) {
+                case SERVICE_E_SUCCESS:
+                        return OSTRACE_E_SUCCESS;
+                case SERVICE_E_INVALID_ARG:
+                        return OSTRACE_E_INVALID_ARG;
+                case SERVICE_E_MUX_ERROR:
+                        return OSTRACE_E_MUX_ERROR;
+                case SERVICE_E_SSL_ERROR:
+                        return OSTRACE_E_SSL_ERROR;
+                case SERVICE_E_NOT_ENOUGH_DATA:
+                        return OSTRACE_E_NOT_ENOUGH_DATA;
+                case SERVICE_E_TIMEOUT:
+                        return OSTRACE_E_TIMEOUT;
+                default:
+                        break;
+        }
+        return OSTRACE_E_UNKNOWN_ERROR;
+}
+
+ostrace_error_t ostrace_client_new(idevice_t device, lockdownd_service_descriptor_t service, ostrace_client_t * client)
+{
+        *client = NULL;
+
+        if (!device || !service || service->port == 0 || !client || *client) {
+                debug_info("Incorrect parameter passed to ostrace_client_new.");
+                return OSTRACE_E_INVALID_ARG;
+        }
+
+        debug_info("Creating ostrace_client, port = %d.", service->port);
+
+        service_client_t parent = NULL;
+        ostrace_error_t ret = ostrace_error(service_client_new(device, service, &parent));
+        if (ret != OSTRACE_E_SUCCESS) {
+                debug_info("Creating base service client failed. Error: %i", ret);
+                return ret;
+        }
+
+        ostrace_client_t client_loc = (ostrace_client_t) malloc(sizeof(struct ostrace_client_private));
+        client_loc->parent = parent;
+        client_loc->worker = THREAD_T_NULL;
+
+        *client = client_loc;
+
+        debug_info("ostrace_client successfully created.");
+        return 0;
+}
+
+ostrace_error_t ostrace_client_start_service(idevice_t device, ostrace_client_t * client, const char* label)
+{
+        ostrace_error_t err = OSTRACE_E_UNKNOWN_ERROR;
+        service_client_factory_start_service(device, OSTRACE_SERVICE_NAME, (void**)client, label, SERVICE_CONSTRUCTOR(ostrace_client_new), &err);
+        return err;
+}
+
+ostrace_error_t ostrace_client_free(ostrace_client_t client)
+{
+        if (!client)
+                return OSTRACE_E_INVALID_ARG;
+        ostrace_stop_activity(client);
+        ostrace_error_t err = ostrace_error(service_client_free(client->parent));
+        free(client);
+
+        return err;
+}
+
+static ostrace_error_t ostrace_send_plist(ostrace_client_t client, plist_t plist)
+{
+        ostrace_error_t res = OSTRACE_E_UNKNOWN_ERROR;
+        uint32_t blen = 0;
+        char* bin = NULL;
+        uint32_t sent = 0;
+        uint32_t swapped_len = 0;
+
+        if (!client || !plist) {
+                return OSTRACE_E_INVALID_ARG;
+        }
+
+        plist_to_bin(plist, &bin, &blen);
+        swapped_len = htobe32(blen);
+
+        res = ostrace_error(service_send(client->parent, (char*)&swapped_len, 4, &sent));
+        if (res == OSTRACE_E_SUCCESS) {
+                res = ostrace_error(service_send(client->parent, bin, blen, &sent));
+        }
+        free(bin);
+        return res;
+}
+
+static ostrace_error_t ostrace_receive_plist(ostrace_client_t client, plist_t *plist)
+{
+        ostrace_error_t res = OSTRACE_E_UNKNOWN_ERROR;
+        uint8_t msgtype = 0;
+        uint32_t received = 0;
+        res = ostrace_error(service_receive(client->parent, (char*)&msgtype, 1, &received));
+        if (res != OSTRACE_E_SUCCESS) {
+                debug_info("Failed to read message type from service");
+                return res;
+        }
+        uint32_t rlen = 0;
+        res = ostrace_error(service_receive(client->parent, (char*)&rlen, 4, &received));
+        if (res != OSTRACE_E_SUCCESS) {
+                debug_info("Failed to read message size from service");
+                return res;
+        }
+
+        if (msgtype == 1) {
+                rlen = be32toh(rlen);
+        } else if (msgtype == 2) {
+                rlen = le32toh(rlen);
+        } else {
+                debug_info("Unexpected message type %d", msgtype);
+                return OSTRACE_E_UNKNOWN_ERROR;
+        }
+        debug_info("got length %d", rlen);
+
+        char* buf = (char*)malloc(rlen);
+        res = ostrace_error(service_receive(client->parent, buf, rlen, &received));
+        if (res != OSTRACE_E_SUCCESS) {
+                return res;
+        }
+
+        plist_t reply = NULL;
+        plist_err_t perr = plist_from_memory(buf, received, &reply, NULL);
+        free(buf);
+        if (perr != PLIST_ERR_SUCCESS) {
+                return OSTRACE_E_UNKNOWN_ERROR;
+        }
+        *plist = reply;
+        return OSTRACE_E_SUCCESS;       
+}
+
+static ostrace_error_t _ostrace_check_result(plist_t reply)
+{
+        ostrace_error_t res = OSTRACE_E_REQUEST_FAILED;
+        if (!reply) {
+                return res;
+        }
+        plist_t p_status = plist_dict_get_item(reply, "Status");
+        if (!p_status) {
+                return res;
+        }
+        const char* status = plist_get_string_ptr(p_status, NULL);
+        if (!status) {
+                return res;
+        }
+        if (!strcmp(status, "RequestSuccessful")) {
+                res = OSTRACE_E_SUCCESS;
+        }
+        return res;
+}
+
+void *ostrace_worker(void *arg)
+{
+        ostrace_error_t res = OSTRACE_E_UNKNOWN_ERROR;
+        struct ostrace_worker_thread *oswt = (struct ostrace_worker_thread*)arg;
+
+        if (!oswt)
+                return NULL;
+
+        uint8_t msgtype = 0;
+        uint32_t received = 0;
+
+        debug_info("Running");
+
+        while (oswt->client->parent) {
+                res = ostrace_error(service_receive_with_timeout(oswt->client->parent, (char*)&msgtype, 1, &received, 100));
+                if (res == OSTRACE_E_TIMEOUT) {
+                        continue;
+                }
+                if (res != OSTRACE_E_SUCCESS) {
+                        debug_info("Failed to read message type from service");
+                        break;
+                }
+                uint32_t rlen = 0;
+                res = ostrace_error(service_receive(oswt->client->parent, (char*)&rlen, 4, &received));
+                if (res != OSTRACE_E_SUCCESS) {
+                        debug_info("Failed to read message size from service");
+                        break;
+                }
+
+                if (msgtype == 1) {
+                        rlen = be32toh(rlen);
+                } else if (msgtype == 2) {
+                        rlen = le32toh(rlen);
+                } else {
+                        debug_info("Unexpected message type %d", msgtype);
+                        break;
+                }
+
+                debug_info("got length %d", rlen);
+
+                void* buf = malloc(rlen);
+                res = ostrace_error(service_receive(oswt->client->parent, (char*)buf, rlen, &received));
+                if (res != OSTRACE_E_SUCCESS) {
+                        debug_info("Failed to receive %d bytes, error %d", rlen, res);
+                        break;
+                }
+                if (received < rlen) {
+                        debug_info("Failed to receive all data, got %d/%d", received, rlen);
+                        break;
+                }
+                oswt->cbfunc(buf, received, oswt->user_data);
+        }
+
+        if (oswt) {
+                free(oswt);
+        }
+
+        debug_info("Exiting");
+
+        return NULL;
+}
+
+ostrace_error_t ostrace_start_activity(ostrace_client_t client, plist_t options, ostrace_activity_cb_t callback, void* user_data)
+{
+        if (!client || !callback)
+                return OSTRACE_E_INVALID_ARG;
+
+        ostrace_error_t res = OSTRACE_E_UNKNOWN_ERROR;
+
+        if (client->worker) {
+                debug_info("Another ostrace activity thread appears to be running already.");
+                return res;
+        }
+
+        plist_t dict = plist_new_dict();
+        plist_dict_set_item(dict, "Pid", plist_new_uint(0x0FFFFFFFF));
+        plist_dict_set_item(dict, "MessageFilter", plist_new_uint(0xFFFF));
+        plist_dict_set_item(dict, "StreamFlags", plist_new_uint(0x3C));
+        if (options) {
+                plist_dict_merge(&dict, options);
+        }
+        plist_dict_set_item(dict, "Request", plist_new_string("StartActivity"));
+
+        res = ostrace_send_plist(client, dict);
+        plist_free(dict);
+        if (res != OSTRACE_E_SUCCESS) {
+                return res;
+        }
+        
+        dict = NULL;
+        res = ostrace_receive_plist(client, &dict);
+        if (res != OSTRACE_E_SUCCESS) {
+                return res;
+        }
+        res = _ostrace_check_result(dict);
+        if (res != OSTRACE_E_SUCCESS) {
+                return res;
+        }
+
+        /* start worker thread */
+        struct ostrace_worker_thread *oswt = (struct ostrace_worker_thread*)malloc(sizeof(struct ostrace_worker_thread));
+        if (oswt) {
+                oswt->client = client;
+                oswt->cbfunc = callback;
+                oswt->user_data = user_data;
+
+                if (thread_new(&client->worker, ostrace_worker, oswt) == 0) {
+                        res = OSTRACE_E_SUCCESS;
+                }
+        }
+
+        return res;
+}
+
+ostrace_error_t ostrace_stop_activity(ostrace_client_t client)
+{
+        if (client->worker) {
+                /* notify thread to finish */
+                service_client_t parent = client->parent;
+                client->parent = NULL;
+                /* join thread to make it exit */
+                thread_join(client->worker);
+                thread_free(client->worker);
+                client->worker = THREAD_T_NULL;
+                client->parent = parent;
+        }
+
+        return OSTRACE_E_SUCCESS;
+}
+
+ostrace_error_t ostrace_get_pid_list(ostrace_client_t client, plist_t* list)
+{
+        ostrace_error_t res = OSTRACE_E_UNKNOWN_ERROR;
+        plist_t dict = plist_new_dict();
+        plist_dict_set_item(dict, "Request", plist_new_string("PidList"));
+
+        if (!client || !list) {
+                return OSTRACE_E_INVALID_ARG;
+        }
+
+        res = ostrace_send_plist(client, dict);
+        plist_free(dict);
+        if (res != OSTRACE_E_SUCCESS) {
+                return res;
+        }
+
+        plist_t reply = NULL;
+        res = ostrace_receive_plist(client, &reply);
+        if (res != OSTRACE_E_SUCCESS) {
+                return res;
+        }
+        res = _ostrace_check_result(reply);
+        if (res != OSTRACE_E_SUCCESS) {
+                return res;
+        }
+
+        plist_t payload = plist_dict_get_item(reply, "Payload");
+        if (!payload) {
+                return OSTRACE_E_REQUEST_FAILED;
+        }
+        *list = plist_copy(payload);
+        plist_free(reply);
+
+        return OSTRACE_E_SUCCESS;
+}
+
+ostrace_error_t ostrace_create_archive(ostrace_client_t client, plist_t options, ostrace_archive_write_cb_t callback, void* user_data)
+{
+        ostrace_error_t res = OSTRACE_E_UNKNOWN_ERROR;
+        if (!client || !callback) {
+                return OSTRACE_E_INVALID_ARG;
+        }
+        plist_t dict = plist_new_dict();
+        if (options) {
+                plist_dict_merge(&dict, options);
+        }
+        plist_dict_set_item(dict, "Request", plist_new_string("CreateArchive"));
+
+        res = ostrace_send_plist(client, dict);
+        plist_free(dict);
+        if (res != OSTRACE_E_SUCCESS) {
+                return res;
+        }
+
+        plist_t reply = NULL;
+        res = ostrace_receive_plist(client, &reply);
+        if (res != OSTRACE_E_SUCCESS) {
+                return res;
+        }
+
+        res = _ostrace_check_result(reply);
+        if (res != OSTRACE_E_SUCCESS) {
+                return res;
+        }
+
+        debug_info("Receiving archive...\n");
+        while (1) {
+                uint8_t msgtype = 0;
+                uint32_t received = 0;
+                res = ostrace_error(service_receive(client->parent, (char*)&msgtype, 1, &received));
+                if (res != OSTRACE_E_SUCCESS) {
+                        debug_info("Could not read message type from service: %d", res);
+                        break;
+                }
+                if (msgtype != 3) {
+                        debug_info("Unexpected packet type %d", msgtype);
+                        return OSTRACE_E_REQUEST_FAILED;
+                }
+                uint32_t rlen = 0;
+                res = ostrace_error(service_receive(client->parent, (char*)&rlen, 4, &received));
+                if (res != OSTRACE_E_SUCCESS) {
+                        debug_info("Failed to read message size from service");
+                        break;
+                }
+
+                rlen = le32toh(rlen);
+                debug_info("got length %d", rlen);
+
+                unsigned char* buf = (unsigned char*)malloc(rlen);
+                res = ostrace_error(service_receive(client->parent, (char*)buf, rlen, &received));
+                if (res != OSTRACE_E_SUCCESS) {
+                        debug_info("Could not read data from service: %d", res);
+                        break;
+                }
+                if (callback(buf, received, user_data) < 0) {
+                        debug_info("Aborted through callback");
+                        return OSTRACE_E_REQUEST_FAILED;
+                }
+        }
+        debug_info("Done.\n");
+
+        return OSTRACE_E_SUCCESS;
+}
+
diff --git a/src/ostrace.h b/src/ostrace.h
new file mode 100644
index 0000000..dcc3e8d
--- /dev/null
+++ b/src/ostrace.h
@@ -0,0 +1,37 @@
+/*
+ * ostrace.h
+ * com.apple.os_trace_relay service header file.
+ *
+ * Copyright (c) 2020-2025 Nikias Bassen, All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef _OSTRACE_H
+#define _OSTRACE_H
+
+#include "idevice.h"
+#include "libimobiledevice/ostrace.h"
+#include "service.h"
+#include <libimobiledevice-glue/thread.h>
+
+struct ostrace_client_private {
+        service_client_t parent;
+        THREAD_T worker;
+};
+
+void *ostrace_worker(void *arg);
+
+#endif
diff --git a/src/sbservices.c b/src/sbservices.c
index 365e130..5df5122 100644
--- a/src/sbservices.c
+++ b/src/sbservices.c
@@ -24,7 +24,11 @@
 #endif
 #include <string.h>
 #include <stdlib.h>
+
+#ifndef _MSC_VER
 #include <unistd.h>
+#endif
+
 #include <plist/plist.h>
 
 #include "sbservices.h"