too much stuff and it WORKS

1 files changed, 527 insertions, 56 deletions

diff --git a/device.c b/device.c
index 79ec00c..ead8b9e 100644
--- a/device.c
+++ b/device.c
@@ -24,25 +24,43 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 #include <config.h>
 #endif
 
+#include <sys/time.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdint.h>
+#include <inttypes.h>
 #include "device.h"
+#include "client.h"
 #include "usb.h"
 #include "log.h"
 
 int next_device_id;
 
+#define DEV_PKTBUF_SIZE 65536
+
+#define CONN_INBUF_SIZE         262144
+#define CONN_OUTBUF_SIZE        65536
+
+#define ACK_TIMEOUT 60
+
 enum mux_protocol {
         MUX_PROTO_VERSION = 0,
         MUX_PROTO_TCP = IPPROTO_TCP,
 };
 
 enum mux_dev_state {
-        MUXDEV_INIT,
-        MUXDEV_ACTIVE,
-        MUXDEV_DEAD
+        MUXDEV_INIT,    // sent version packet
+        MUXDEV_ACTIVE,  // received version packet, active
+        MUXDEV_DEAD             // dead
+};
+
+enum mux_conn_state {
+        CONN_CONNECTING,        // SYN
+        CONN_CONNECTED,         // SYN/SYNACK/ACK -> active
+        CONN_DYING,                     // RST received
+        CONN_DEAD                       // being freed; used to prevent infinite recursion between client<->device freeing
 };
 
 struct mux_header
@@ -58,45 +76,67 @@ struct version_header
         uint32_t padding;
 };
 
+struct mux_device;
+
+#define CONN_ACK_PENDING 1
+
+struct mux_connection
+{
+        struct mux_device *dev;
+        struct mux_client *client;
+        enum mux_conn_state state;
+        uint16_t sport, dport;
+        uint32_t tx_seq, tx_ack, tx_acked, tx_win;
+        uint32_t rx_seq, rx_recvd, rx_ack, rx_win;
+        int max_payload;
+        int sendable;
+        int flags;
+        unsigned char *ib_buf;
+        int ib_size;
+        int ib_capacity;
+        unsigned char *ob_buf;
+        int ob_capacity;
+        short events;
+        uint64_t last_ack_time;
+};
+
 struct mux_device
 {
         struct usb_device *usbdev;
         int id;
         enum mux_dev_state state;
+        struct collection connections;
+        uint16_t next_sport;
+        unsigned char *pktbuf;
+        int pktlen;
 };
 
-static int num_devs;
-static struct mux_device *device_list;
+static struct collection device_list;
 
-static int alloc_device(void)
+uint64_t mstime64(void)
 {
-        int i;
-        for(i=0; i<num_devs; i++) {
-                if(!device_list[i].usbdev)
-                        return i;
-        }
-        num_devs++;
-        device_list = realloc(device_list, sizeof(*device_list) * num_devs);
-        memset(&device_list[num_devs-1], 0, sizeof(*device_list));
-        return num_devs - 1;
+        struct timeval tv;
+        gettimeofday(&tv, NULL);
+        return tv.tv_sec * 1000 + tv.tv_usec / 1000;
 }
 
 static int get_next_device_id(void)
 {
-        int i;
         while(1) {
-                for(i=0; i<num_devs; i++) {
-                        if(device_list[i].usbdev && device_list[i].id == next_device_id) {
+                int ok = 1;
+                FOREACH(struct mux_device *dev, &device_list) {
+                        if(dev->id == next_device_id) {
                                 next_device_id++;
+                                ok = 0;
                                 break;
                         }
-                }
-                if(i >= num_devs)
+                } ENDFOREACH
+                if(ok)
                         return next_device_id++;
         }
 }
 
-int send_packet(struct mux_device *dev, enum mux_protocol proto, void *header, void *data, int length)
+static int send_packet(struct mux_device *dev, enum mux_protocol proto, void *header, const void *data, int length)
 {
         unsigned char *buffer;
         int hdrlen;
@@ -135,7 +175,246 @@ int send_packet(struct mux_device *dev, enum mux_protocol proto, void *header, v
                 free(buffer);
                 return res;
         }
-        return mhdr->length;
+        return total;
+}
+
+static uint16_t find_sport(struct mux_device *dev)
+{
+        if(collection_count(&dev->connections) >= 65535)
+                return 0; //insanity
+        
+        while(1) {
+                int ok = 1;
+                FOREACH(struct mux_connection *conn, &dev->connections) {
+                        if(dev->next_sport == conn->sport) {
+                                dev->next_sport++;
+                                ok = 0;
+                                break;
+                        }
+                } ENDFOREACH
+                if(ok)
+                        return dev->next_sport++;
+        }
+}
+
+static int send_tcp(struct mux_connection *conn, uint8_t flags, const unsigned char *data, int length)
+{
+        struct tcphdr th;
+        memset(&th, 0, sizeof(th));
+        th.th_sport = htons(conn->sport);
+        th.th_dport = htons(conn->dport);
+        th.th_seq = htonl(conn->tx_seq);
+        th.th_ack = htonl(conn->tx_ack);
+        th.th_flags = flags;
+        th.th_off = sizeof(th) / 4;
+        th.th_win = htons(conn->tx_win >> 8);
+        
+        usbmuxd_log(LL_DEBUG, "[OUT] dev=%d sport=%d dport=%d seq=%d ack=%d flags=0x%x window=%d[%d] len=%d",
+                conn->dev->id, conn->sport, conn->dport, conn->tx_seq, conn->tx_ack, flags, conn->tx_win, conn->tx_win >> 8, length);
+
+        int res = send_packet(conn->dev, MUX_PROTO_TCP, &th, data, length);
+        if(res >= 0) {
+                conn->tx_acked = conn->tx_ack;
+                conn->last_ack_time = mstime64();
+                conn->flags &= ~CONN_ACK_PENDING;
+        }
+        return res;
+}
+
+static void connection_teardown(struct mux_connection *conn)
+{
+        int res;
+        if(conn->state == CONN_DEAD)
+                return;
+        usbmuxd_log(LL_DEBUG, "connection_teardown dev %d sport %d dport %d", conn->dev->id, conn->sport, conn->dport);
+        if(conn->dev->state != MUXDEV_DEAD && conn->state != CONN_DYING) {
+                res = send_tcp(conn, TH_RST, NULL, 0);
+                if(res < 0)
+                        usbmuxd_log(LL_ERROR, "Error sending TCP RST to device %d (%d->%d)", conn->dev->id, conn->sport, conn->dport);
+        }
+        if(conn->client) {
+                if(conn->state == CONN_CONNECTING) {
+                        client_notify_connect(conn->client, RESULT_CONNREFUSED);
+                } else {
+                        conn->state = CONN_DEAD;
+                        client_close(conn->client);
+                }
+        }
+        if(conn->ib_buf)
+                free(conn->ib_buf);
+        if(conn->ob_buf)
+                free(conn->ob_buf);
+        collection_remove(&conn->dev->connections, conn);
+        free(conn);
+}
+
+int device_start_connect(int device_id, uint16_t dport, struct mux_client *client)
+{
+        struct mux_device *dev = NULL;
+        FOREACH(struct mux_device *cdev, &device_list) {
+                if(cdev->id == device_id) {
+                        dev = cdev;
+                        break;
+                }
+        } ENDFOREACH
+        if(!dev) {
+                usbmuxd_log(LL_WARNING, "Attempted to connect to nonexistent device %d", device_id);
+                return -RESULT_BADDEV;
+        }
+        
+        uint16_t sport = find_sport(dev);
+        if(!sport) {
+                usbmuxd_log(LL_WARNING, "Unable to allocate port for device %d", device_id);
+                return -RESULT_BADDEV;
+        }
+
+        struct mux_connection *conn;
+        conn = malloc(sizeof(struct mux_connection));
+        memset(conn, 0, sizeof(struct mux_connection));
+        
+        conn->dev = dev;
+        conn->client = client;
+        conn->state = CONN_CONNECTING;
+        conn->sport = sport;
+        conn->dport = dport;
+        conn->tx_seq = 0;
+        conn->tx_ack = 0;
+        conn->tx_acked = 0;
+        conn->tx_win = 131072;
+        conn->rx_recvd = 0;
+        conn->flags = 0;
+        conn->max_payload = USB_MTU - sizeof(struct mux_header) - sizeof(struct tcphdr);
+        
+        conn->ob_buf = malloc(CONN_OUTBUF_SIZE);
+        conn->ob_capacity = CONN_OUTBUF_SIZE;
+        conn->ib_buf = malloc(CONN_INBUF_SIZE);
+        conn->ib_capacity = CONN_INBUF_SIZE;
+        conn->ib_size = 0;
+        
+        int res;
+        
+        res = send_tcp(conn, TH_SYN, NULL, 0);
+        if(res < 0) {
+                usbmuxd_log(LL_ERROR, "Error sending TCP SYN to device %d (%d->%d)", dev->id, sport, dport);
+                free(conn);
+                return -RESULT_CONNREFUSED; //bleh
+        }
+        collection_add(&dev->connections, conn);
+        return 0;
+}
+
+static void update_connection(struct mux_connection *conn)
+{
+        conn->sendable = conn->rx_win - (conn->tx_seq - conn->rx_ack);
+        
+        if(conn->sendable > conn->ob_capacity)
+                conn->sendable = conn->ob_capacity;
+        if(conn->sendable > conn->max_payload)
+                conn->sendable = conn->max_payload;
+        
+        if(conn->sendable > 0)
+                conn->events |= POLLIN;
+        else
+                conn->events &= ~POLLIN;
+
+        if(conn->ib_size)
+                conn->events |= POLLOUT;
+        else
+                conn->events &= ~POLLOUT;
+
+        if(conn->tx_acked != conn->tx_ack)
+                conn->flags |= CONN_ACK_PENDING;
+        else
+                conn->flags &= ~CONN_ACK_PENDING;
+
+        usbmuxd_log(LL_SPEW, "update_connection: sendable %d, events %d, flags %d", conn->sendable, conn->events, conn->flags);
+        client_set_events(conn->client, conn->events);
+}
+
+void device_client_process(int device_id, struct mux_client *client, short events)
+{
+        struct mux_connection *conn = NULL;
+        FOREACH(struct mux_device *dev, &device_list) {
+                if(dev->id == device_id) {
+                        FOREACH(struct mux_connection *lconn, &dev->connections) {
+                                if(lconn->client == client) {
+                                        conn = lconn;
+                                        break;
+                                }
+                        } ENDFOREACH
+                        break;
+                }
+        } ENDFOREACH
+
+        if(!conn) {
+                usbmuxd_log(LL_WARNING, "Could not find connection for device %d client %p", device_id, client);
+                return;
+        }
+        usbmuxd_log(LL_SPEW, "device_client_process (%d)", events);
+        
+        int res;
+        int size;
+        if(events & POLLOUT) {
+                size = client_write(conn->client, conn->ib_buf, conn->ib_size);
+                if(size <= 0) {
+                        usbmuxd_log(LL_DEBUG, "error writing to client (%d)", size);
+                        connection_teardown(conn);
+                        return;
+                }
+                conn->tx_ack += size;
+                if(size == conn->ib_size) {
+                        conn->ib_size = 0;
+                } else {
+                        conn->ib_size -= size;
+                        memmove(conn->ib_buf, conn->ib_buf + size, conn->ib_size);
+                }
+        }
+        if(events & POLLIN) {
+                size = client_read(conn->client, conn->ob_buf, conn->sendable);
+                if(size <= 0) {
+                        usbmuxd_log(LL_DEBUG, "error reading from client (%d)", size);
+                        connection_teardown(conn);
+                        return;
+                }
+                res = send_tcp(conn, TH_ACK, conn->ob_buf, size);
+                if(res < 0) {
+                        connection_teardown(conn);
+                        return;
+                }
+                conn->tx_seq += size;
+        }
+
+        update_connection(conn);
+}
+
+static void connection_device_input(struct mux_connection *conn, unsigned char *payload, int payload_length)
+{
+        if((conn->ib_size + payload_length) > conn->ib_capacity) {
+                usbmuxd_log(LL_ERROR, "Input buffer overflow on device %d connection %d->%d (space=%d, payload=%d)", conn->dev->id, conn->sport, conn->dport, conn->ib_capacity-conn->ib_size, payload_length);
+                connection_teardown(conn);
+                return;
+        }
+        memcpy(conn->ib_buf + conn->ib_size, payload, payload_length);
+        conn->ib_size += payload_length;
+        conn->rx_recvd += payload_length;
+        update_connection(conn);
+}
+
+void device_abort_connect(int device_id, struct mux_client *client)
+{
+        FOREACH(struct mux_device *dev, &device_list) {
+                if(dev->id == device_id) {
+                        FOREACH(struct mux_connection *conn, &dev->connections) {
+                                if(conn->client == client) {
+                                        connection_teardown(conn);
+                                        return;
+                                }
+                        } ENDFOREACH
+                        usbmuxd_log(LL_WARNING, "Attempted to abort for nonexistent connection for device %d", device_id);
+                        return;
+                }
+        } ENDFOREACH
+        usbmuxd_log(LL_WARNING, "Attempted to abort connection for nonexistent device %d", device_id);
 }
 
 static void device_version_input(struct mux_device *dev, struct version_header *vh)
@@ -148,33 +427,131 @@ static void device_version_input(struct mux_device *dev, struct version_header *
         vh->minor = ntohl(vh->minor);
         if(vh->major != 1 || vh->minor != 0) {
                 usbmuxd_log(LL_ERROR, "Device %d has unknown version %d.%d\n", dev->id, vh->major, vh->minor);
+                collection_remove(&device_list, dev);
+                free(dev);
                 return;
         }
         usbmuxd_log(LL_NOTICE, "Connected to v%d.%d device %d on location 0x%x with serial number %s", vh->major, vh->minor, dev->id, usb_get_location(dev->usbdev), usb_get_serial(dev->usbdev));
+        dev->state = MUXDEV_ACTIVE;
+        collection_init(&dev->connections);
+        struct device_info info;
+        info.id = dev->id;
+        info.location = usb_get_location(dev->usbdev);
+        info.serial = usb_get_serial(dev->usbdev);
+        info.pid = usb_get_pid(dev->usbdev);
+        client_device_add(&info);
 }
 
 static void device_tcp_input(struct mux_device *dev, struct tcphdr *th, unsigned char *payload, int payload_length)
 {
-
+        usbmuxd_log(LL_DEBUG, "[IN] dev=%d sport=%d dport=%d seq=%d ack=%d flags=0x%x window=%d[%d] len=%d",
+                dev->id, ntohs(th->th_sport), ntohs(th->th_dport), ntohl(th->th_seq), ntohl(th->th_ack), th->th_flags, ntohs(th->th_win) << 8, ntohs(th->th_win), payload_length);
+        
+        uint16_t sport = ntohs(th->th_dport);
+        uint16_t dport = ntohs(th->th_sport);
+        struct mux_connection *conn = NULL;
+        FOREACH(struct mux_connection *lconn, &dev->connections) {
+                if(lconn->sport == sport && lconn->dport == dport) {
+                        conn = lconn;
+                        break;
+                }
+        } ENDFOREACH
+        
+        if(!conn) {
+                usbmuxd_log(LL_WARNING, "No connection for device %d incoming packet %d->%d", dev->id, dport, sport);
+                return;
+        }
+        
+        conn->rx_seq = ntohl(th->th_seq);
+        conn->rx_ack = ntohl(th->th_ack);
+        conn->rx_win = ntohs(th->th_win) << 8;
+        
+        if(th->th_flags & TH_RST) {
+                char *buf = malloc(payload_length+1);
+                memcpy(buf, payload, payload_length);
+                if(payload_length && (buf[payload_length-1] == '\n'))
+                        buf[payload_length-1] = 0;
+                buf[payload_length] = 0;
+                usbmuxd_log(LL_DEBUG, "RST reason: %s", buf);
+                free(buf);
+        }
+        
+        if(conn->state == CONN_CONNECTING) {
+                if(th->th_flags != (TH_SYN|TH_ACK)) {
+                        if(th->th_flags & TH_RST)
+                                conn->state = CONN_DYING;
+                        usbmuxd_log(LL_INFO, "Connection refused by device %d (%d->%d)", dev->id, sport, dport);
+                        connection_teardown(conn); //this also sends the notification to the client
+                } else {
+                        conn->tx_seq++;
+                        conn->tx_ack++;
+                        conn->rx_recvd = conn->rx_seq;
+                        if(send_tcp(conn, TH_ACK, NULL, 0) < 0) {
+                                usbmuxd_log(LL_ERROR, "Error sending TCP ACK to device %d (%d->%d)", dev->id, sport, dport);
+                                connection_teardown(conn);
+                                return;
+                        }
+                        conn->state = CONN_CONNECTED;
+                        if(client_notify_connect(conn->client, RESULT_OK) < 0) {
+                                conn->client = NULL;
+                                connection_teardown(conn);
+                        }
+                        update_connection(conn);
+                }
+        } else if(conn->state == CONN_CONNECTED) {
+                if(th->th_flags != TH_ACK) {
+                        usbmuxd_log(LL_INFO, "Connection reset by device %d (%d->%d)", dev->id, sport, dport);
+                        if(th->th_flags & TH_RST)
+                                conn->state = CONN_DYING;
+                        connection_teardown(conn);
+                } else {
+                        connection_device_input(conn, payload, payload_length);
+                }
+        }
 }
 
-
 void device_data_input(struct usb_device *usbdev, unsigned char *buffer, int length)
 {
-        int i;
-        struct mux_device *dev;
-        for(i=0; i<num_devs; i++) {
-                if(device_list[i].usbdev == usbdev) {
-                        dev = &device_list[i];
+        struct mux_device *dev = NULL;
+        FOREACH(struct mux_device *tdev, &device_list) {
+                if(tdev->usbdev == usbdev) {
+                        dev = tdev;
                         break;
                 }
-        }
-        if(i >= num_devs) {
+        } ENDFOREACH
+        if(!dev) {
                 usbmuxd_log(LL_WARNING, "Cannot find device entry for RX input from USB device %p on location 0x%x", usbdev, usb_get_location(usbdev));
                 return;
         }
         
+        if(!length)
+                return;
+        
         usbmuxd_log(LL_SPEW, "Mux data input for device %p: %p len %d", dev, buffer, length);
+
+        // handle broken up transfers
+        if(dev->pktlen) {
+                memcpy(dev->pktbuf + dev->pktlen, buffer, length);
+                struct mux_header *mhdr = (struct mux_header *)dev->pktbuf;
+                if((length < USB_MRU) || (ntohl(mhdr->length) == length)) {
+                        buffer = dev->pktbuf;
+                        length += dev->pktlen;
+                        dev->pktlen = 0;
+                        usbmuxd_log(LL_SPEW, "Gathered mux data from buffer (total size: %d)", length);
+                } else {
+                        dev->pktlen += length;
+                        usbmuxd_log(LL_SPEW, "Appended mux data to buffer (total size: %d)", dev->pktlen);
+                        return;
+                }
+        } else {
+                struct mux_header *mhdr = (struct mux_header *)buffer;
+                if((length == USB_MRU) && (length < ntohl(mhdr->length))) {
+                        memcpy(dev->pktbuf, buffer, length);
+                        dev->pktlen = length;
+                        usbmuxd_log(LL_SPEW, "Copied mux data to buffer (size: %d)", dev->pktlen);
+                        return;
+                }
+        }
         
         struct mux_header *mhdr = (struct mux_header *)buffer;
         
@@ -204,56 +581,150 @@ void device_data_input(struct usb_device *usbdev, unsigned char *buffer, int len
         
 }
 
-int device_add(struct usb_device *dev)
+int device_add(struct usb_device *usbdev)
 {
         int res;
         int id = get_next_device_id();
-        int idx = alloc_device();
-        usbmuxd_log(LL_NOTICE, "Connecting to new device on location 0x%x as ID %d", usb_get_location(dev), id);
-        device_list[idx].id = id;
-        device_list[idx].usbdev = dev;
-        device_list[idx].state = MUXDEV_INIT;
+        struct mux_device *dev;
+        usbmuxd_log(LL_NOTICE, "Connecting to new device on location 0x%x as ID %d", usb_get_location(usbdev), id);
+        dev = malloc(sizeof(struct mux_device));
+        dev->id = id;
+        dev->usbdev = usbdev;
+        dev->state = MUXDEV_INIT;
+        dev->next_sport = 1;
+        dev->pktbuf = malloc(DEV_PKTBUF_SIZE);
+        dev->pktlen = 0;
         struct version_header vh;
         vh.major = htonl(1);
         vh.minor = htonl(0);
         vh.padding = 0;
-        if((res = send_packet(&device_list[idx], MUX_PROTO_VERSION, &vh, NULL, 0)) < 0) {
+        if((res = send_packet(dev, MUX_PROTO_VERSION, &vh, NULL, 0)) < 0) {
                 usbmuxd_log(LL_ERROR, "Error sending version request packet to device %d\n", id);
-                device_list[idx].usbdev = NULL;
-                device_list[idx].state = MUXDEV_DEAD;
+                free(dev);
                 return res;
         }
+        collection_add(&device_list, dev);
         return 0;
 }
 
-void device_remove(struct usb_device *dev)
+void device_remove(struct usb_device *usbdev)
 {
-        int i;
-        for(i=0; i<num_devs; i++) {
-                if(device_list[i].usbdev == dev) {
-                        usbmuxd_log(LL_NOTICE, "Removed device %d on location 0x%x", device_list[i].id, usb_get_location(dev));
-                        device_list[i].usbdev = NULL;
+        FOREACH(struct mux_device *dev, &device_list) {
+                if(dev->usbdev == usbdev) {
+                        usbmuxd_log(LL_NOTICE, "Removed device %d on location 0x%x", dev->id, usb_get_location(usbdev));
+                        if(dev->state == MUXDEV_ACTIVE) {
+                                dev->state = MUXDEV_DEAD;
+                                FOREACH(struct mux_connection *conn, &dev->connections) {
+                                        connection_teardown(conn);
+                                } ENDFOREACH
+                                client_device_remove(dev->id);
+                                collection_free(&dev->connections);
+                        }
+                        collection_remove(&device_list, dev);
+                        free(dev->pktbuf);
+                        free(dev);
                         return;
                 }
-        }
-        usbmuxd_log(LL_WARNING, "Cannot find device entry while removing USB device %p on location 0x%x", dev, usb_get_location(dev));
+        } ENDFOREACH
+        usbmuxd_log(LL_WARNING, "Cannot find device entry while removing USB device %p on location 0x%x", usbdev, usb_get_location(usbdev));
+}
+
+int device_get_count(void)
+{
+        int count = 0;
+        FOREACH(struct mux_device *dev, &device_list) {
+                if(dev->state == MUXDEV_ACTIVE)
+                        count++;
+        } ENDFOREACH
+        return count;
+}
+
+int device_get_list(struct device_info *p)
+{
+        int count = 0;
+        FOREACH(struct mux_device *dev, &device_list) {
+                if(dev->state == MUXDEV_ACTIVE) {
+                        p->id = dev->id;
+                        p->serial = usb_get_serial(dev->usbdev);
+                        p->location = usb_get_location(dev->usbdev);
+                        p->pid = usb_get_pid(dev->usbdev);
+                        count++;
+                        p++;
+                }
+        } ENDFOREACH
+        return count;
+}
+
+int device_get_timeout(void)
+{
+        uint64_t oldest = (uint64_t)-1;
+        FOREACH(struct mux_device *dev, &device_list) {
+                if(dev->state == MUXDEV_ACTIVE) {
+                        FOREACH(struct mux_connection *conn, &dev->connections) {
+                                if((conn->state == CONN_CONNECTED) && (conn->flags & CONN_ACK_PENDING) && conn->last_ack_time < oldest)
+                                        oldest = conn->last_ack_time;
+                        } ENDFOREACH
+                }
+        } ENDFOREACH
+        uint64_t ct = mstime64();
+        if(oldest == -1)
+                return 100000; //meh
+        if((ct - oldest) > ACK_TIMEOUT)
+                return 0;
+        return ACK_TIMEOUT - (ct - oldest);
+}
+
+void device_check_timeouts(void)
+{
+        uint64_t ct = mstime64();
+        FOREACH(struct mux_device *dev, &device_list) {
+                if(dev->state == MUXDEV_ACTIVE) {
+                        FOREACH(struct mux_connection *conn, &dev->connections) {
+                                if((conn->state == CONN_CONNECTED) && 
+                                                (conn->flags & CONN_ACK_PENDING) && 
+                                                (ct - conn->last_ack_time) > ACK_TIMEOUT) {
+                                        usbmuxd_log(LL_DEBUG, "Sending ACK due to expired timeout (%" PRIu64 " -> %" PRIu64 ")", conn->last_ack_time, ct);
+                                        if(send_tcp(conn, TH_ACK, NULL, 0) < 0) {
+                                                usbmuxd_log(LL_ERROR, "Error sending TCP ACK to device %d (%d->%d)", dev->id, conn->sport, conn->dport);
+                                                connection_teardown(conn);
+                                        }
+                                }
+                        } ENDFOREACH
+                }
+        } ENDFOREACH
 }
 
 void device_init(void)
 {
         usbmuxd_log(LL_DEBUG, "device_init");
-        num_devs = 1;
-        device_list = malloc(sizeof(*device_list) * num_devs);
-        memset(device_list, 0, sizeof(*device_list) * num_devs);
+        collection_init(&device_list);
         next_device_id = 1;
 }
 
+void device_kill_connections(void)
+{
+        usbmuxd_log(LL_DEBUG, "device_kill_connections");
+        FOREACH(struct mux_device *dev, &device_list) {
+                if(dev->state != MUXDEV_INIT) {
+                        FOREACH(struct mux_connection *conn, &dev->connections) {
+                                connection_teardown(conn);
+                        } ENDFOREACH
+                }
+        } ENDFOREACH
+        // give USB a while to send the final connection RSTs and the like
+        usb_process_timeout(100);
+}
+
 void device_shutdown(void)
 {
-        int i;
         usbmuxd_log(LL_DEBUG, "device_shutdown");
-        for(i=0; i<num_devs; i++)
-                device_remove(device_list[i].usbdev);
-        free(device_list);
-        device_list = NULL;
+        FOREACH(struct mux_device *dev, &device_list) {
+                FOREACH(struct mux_connection *conn, &dev->connections) {
+                        connection_teardown(conn);
+                } ENDFOREACH
+                collection_free(&dev->connections);
+                collection_remove(&device_list, dev);
+                free(dev);
+        } ENDFOREACH
+        collection_free(&device_list);
 }