idevicedebugserverproxy: Properly handle server shutdown

1 files changed, 75 insertions, 45 deletions

diff --git a/tools/idevicedebugserverproxy.c b/tools/idevicedebugserverproxy.c
index 2209abc..fc1ead9 100644
--- a/tools/idevicedebugserverproxy.c
+++ b/tools/idevicedebugserverproxy.c
@@ -38,33 +38,25 @@ static int debug_mode = 0;
 static int quit_flag = 0;
 
 typedef struct {
-        int server_fd;
         int client_fd;
-        uint16_t local_port;
         idevice_t device;
         debugserver_client_t debugserver_client;
         volatile int stop_ctod;
         volatile int stop_dtoc;
 } socket_info_t;
 
-static socket_info_t global_socket_info;
+struct thread_info {
+        thread_t th;
+        struct thread_info *next;
+};
+
+typedef struct thread_info thread_info_t;
+
 
 static void clean_exit(int sig)
 {
-        if (quit_flag == 0)
-                fprintf(stderr, "Setting quit status. Cancel again to quit server.\n");
-        else
-                fprintf(stderr, "Exiting...\n");
-
+        fprintf(stderr, "Exiting...\n");
         quit_flag++;
-
-        /* shutdown server socket if we have to terminate to unblock the server loop */
-        if (quit_flag > 1) {
-                if (global_socket_info.server_fd > 0) {
-                        socket_shutdown(global_socket_info.server_fd, SHUT_RDWR);
-                        socket_close(global_socket_info.server_fd);
-                }
-        }
 }
 
 static void print_usage(int argc, char **argv)
@@ -83,7 +75,7 @@ static void print_usage(int argc, char **argv)
 static void *thread_device_to_client(void *data)
 {
         socket_info_t* socket_info = (socket_info_t*)data;
-        idevice_error_t res = IDEVICE_E_UNKNOWN_ERROR;
+        debugserver_error_t res = DEBUGSERVER_E_UNKNOWN_ERROR;
 
         int recv_len;
         int sent;
@@ -92,15 +84,14 @@ static void *thread_device_to_client(void *data)
         debug("%s: started thread...\n", __func__);
 
         debug("%s: client_fd = %d\n", __func__, socket_info->client_fd);
-        debug("%s: server fd = %d\n", __func__, socket_info->server_fd);
 
-        while (!quit_flag && !socket_info->stop_dtoc && socket_info->client_fd > 0 && socket_info->server_fd > 0) {
+        while (!quit_flag && !socket_info->stop_dtoc && socket_info->client_fd > 0) {
                 debug("%s: receiving data from device...\n", __func__);
 
                 res = debugserver_client_receive_with_timeout(socket_info->debugserver_client, buffer, sizeof(buffer), (uint32_t*)&recv_len, 5000);
 
                 if (recv_len <= 0) {
-                        if (recv_len == 0 && res == IDEVICE_E_SUCCESS) {
+                        if (recv_len == 0 && res == DEBUGSERVER_E_SUCCESS) {
                                 // try again
                                 continue;
                         } else {
@@ -139,7 +130,7 @@ static void *thread_device_to_client(void *data)
 static void *thread_client_to_device(void *data)
 {
         socket_info_t* socket_info = (socket_info_t*)data;
-        idevice_error_t res = IDEVICE_E_UNKNOWN_ERROR;
+        debugserver_error_t res = DEBUGSERVER_E_UNKNOWN_ERROR;
 
         int recv_len;
         int sent;
@@ -149,7 +140,6 @@ static void *thread_client_to_device(void *data)
         debug("%s: started thread...\n", __func__);
 
         debug("%s: client_fd = %d\n", __func__, socket_info->client_fd);
-        debug("%s: server_fd = %d\n", __func__, socket_info->server_fd);
 
         /* spawn server to client thread */
         socket_info->stop_dtoc = 0;
@@ -157,7 +147,7 @@ static void *thread_client_to_device(void *data)
                 fprintf(stderr, "Failed to start device to client thread...\n");
         }
 
-        while (!quit_flag && !socket_info->stop_ctod && socket_info->client_fd > 0 && socket_info->server_fd > 0) {
+        while (!quit_flag && !socket_info->stop_ctod && socket_info->client_fd > 0) {
                 debug("%s: receiving data from client...\n", __func__);
 
                 /* attempt to read incoming data from client */
@@ -177,7 +167,7 @@ static void *thread_client_to_device(void *data)
                         debug("%s: sending data to device...\n", __func__);
                         res = debugserver_client_send(socket_info->debugserver_client, buffer, recv_len, (uint32_t*)&sent);
 
-                        if (sent < recv_len || res != IDEVICE_E_SUCCESS) {
+                        if (sent < recv_len || res != DEBUGSERVER_E_SUCCESS) {
                                 if (sent <= 0) {
                                         fprintf(stderr, "send failed: %s\n", strerror(errno));
                                         break;
@@ -245,18 +235,34 @@ static void* connection_handler(void* data)
 int main(int argc, char *argv[])
 {
         idevice_error_t ret = IDEVICE_E_UNKNOWN_ERROR;
-        thread_t th;
+        idevice_t device = NULL;
+        thread_info_t *thread_list = NULL;
         const char* udid = NULL;
         uint16_t local_port = 0;
+        int server_fd;
         int result = EXIT_SUCCESS;
         int i;
 
+#ifndef WIN32
+        struct sigaction sa;
+        struct sigaction si;
+        memset(&sa, '\0', sizeof(struct sigaction));
+        memset(&si, '\0', sizeof(struct sigaction));
+
+        sa.sa_handler = clean_exit;
+        sigemptyset(&sa.sa_mask);
+
+        si.sa_handler = SIG_IGN;
+        sigemptyset(&si.sa_mask);
+
+        sigaction(SIGINT, &sa, NULL);
+        sigaction(SIGTERM, &sa, NULL);
+        sigaction(SIGQUIT, &sa, NULL);
+        sigaction(SIGPIPE, &si, NULL);
+#else
         /* bind signals */
         signal(SIGINT, clean_exit);
         signal(SIGTERM, clean_exit);
-#ifndef WIN32
-        signal(SIGQUIT, clean_exit);
-        signal(SIGPIPE, SIG_IGN);
 #endif
 
         /* parse cmdline arguments */
@@ -297,11 +303,8 @@ int main(int argc, char *argv[])
                 goto leave_cleanup;
         }
 
-        /* setup and create socket endpoint */
-        global_socket_info.local_port = local_port;
-
         /* start services and connect to device */
-        ret = idevice_new(&global_socket_info.device, udid);
+        ret = idevice_new(&device, udid);
         if (ret != IDEVICE_E_SUCCESS) {
                 if (udid) {
                         fprintf(stderr, "No device found with udid %s, is it plugged in?\n", udid);
@@ -313,40 +316,67 @@ int main(int argc, char *argv[])
         }
 
         /* create local socket */
-        global_socket_info.server_fd = socket_create(global_socket_info.local_port);
-        if (global_socket_info.server_fd < 0) {
+        server_fd = socket_create(local_port);
+        if (server_fd < 0) {
                 fprintf(stderr, "Could not create socket\n");
                 result = EXIT_FAILURE;
                 goto leave_cleanup;
         }
 
         while (!quit_flag) {
-                debug("%s: Waiting for connection on local port %d\n", __func__, global_socket_info.local_port);
+                debug("%s: Waiting for connection on local port %d\n", __func__, local_port);
 
                 /* wait for client */
-                global_socket_info.client_fd = socket_accept(global_socket_info.server_fd, global_socket_info.local_port);
-                if (global_socket_info.client_fd < 0) {
+                int client_fd = socket_accept(server_fd, local_port);
+                if (client_fd < 0) {
                         continue;
                 }
 
                 debug("%s: Handling new client connection...\n", __func__);
 
-                if (thread_new(&th, connection_handler, (void*)&global_socket_info) != 0) {
+                thread_info_t *el = (thread_info_t*)malloc(sizeof(thread_info_t));
+                if (!el) {
+                        fprintf(stderr, "Out of memory\n");
+                        exit(EXIT_FAILURE);
+                }
+                el->next = NULL;
+
+                if (thread_list) {
+                        thread_list->next = el;
+                } else {
+                        thread_list = el;
+                }
+
+                socket_info_t *sinfo = (socket_info_t*)malloc(sizeof(socket_info_t));
+                if (!sinfo) {
+                        fprintf(stderr, "Out of memory\n");
+                        exit(EXIT_FAILURE);
+                }
+                sinfo->client_fd = client_fd;
+                sinfo->device = device;
+
+                if (thread_new(&(el->th), connection_handler, (void*)sinfo) != 0) {
                         fprintf(stderr, "Could not start connection handler.\n");
-                        socket_shutdown(global_socket_info.server_fd, SHUT_RDWR);
-                        socket_close(global_socket_info.server_fd);
+                        socket_shutdown(server_fd, SHUT_RDWR);
+                        socket_close(server_fd);
                         continue;
                 }
-
-                /* we do not need it anymore */
-                thread_free(th);
         }
 
         debug("%s: Shutting down debugserver proxy...\n", __func__);
 
+        /* join and clean up threads */
+        while (thread_list) {
+                thread_info_t *el = thread_list;
+                thread_join(el->th);
+                thread_free(el->th);
+                thread_list = el->next;
+                free(el);
+        }
+
 leave_cleanup:
-        if (global_socket_info.device) {
-                idevice_free(global_socket_info.device);
+        if (device) {
+                idevice_free(device);
         }
 
         return result;