Renamed directory 'usbmuxd' to more suitable 'daemon'.

10 files changed, 2604 insertions, 0 deletions

diff --git a/daemon/CMakeLists.txt b/daemon/CMakeLists.txt
new file mode 100644
index 0000000..45565d1
--- /dev/null
+++ b/daemon/CMakeLists.txt
@@ -0,0 +1,32 @@
+find_package(USB REQUIRED)
+include_directories(${USB_INCLUDE_DIRS})
+set(LIBS ${LIBS} ${USB_LIBRARIES})
+
+include_directories (${CMAKE_SOURCE_DIR}/common)
+include_directories (${CMAKE_SOURCE_DIR}/daemon)
+include_directories (${CMAKE_SOURCE_DIR}/libusbmuxd)
+
+include(CheckConstantExists)
+set(CMAKE_REQUIRED_INCLUDES ${USB_INCLUDE_DIRS})
+check_constant_exists(LIBUSB_TRANSFER_ZERO_PACKET libusb.h HAVE_LIBUSB_ZLP)
+
+if(NOT HAVE_LIBUSB_ZLP)
+  message("
+================================================================================
+==================================== WARNING ===================================
+================================================================================
+Your libusb is missing proper Zero Length Packet support! If you are using a
+recent libusb Git, things may or may not work. If you are using libusb 1.0.2 or
+earlier, things will definitely not work properly.
+
+Please apply the patch in the contrib/ directory to your libusb 1.0 tree.
+================================================================================
+")
+  add_definitions(-DEXPLICIT_ZLP_TRANSACTION)
+endif(NOT HAVE_LIBUSB_ZLP)
+
+add_definitions(-Wall -O2 -g -DUSBMUXD_DAEMON)
+add_executable(usbmuxd main.c usb-linux.c log.c ../common/utils.c device.c client.c)
+target_link_libraries(usbmuxd ${LIBS})
+
+install(TARGETS usbmuxd RUNTIME DESTINATION sbin)
diff --git a/daemon/client.c b/daemon/client.c
new file mode 100644
index 0000000..0e47e84
--- /dev/null
+++ b/daemon/client.c
@@ -0,0 +1,430 @@
+/*
+	usbmuxd - iPhone/iPod Touch USB multiplex server daemon
+
+Copyright (C) 2009	Hector Martin "marcan" <hector@marcansoft.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 or version 3.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <arpa/inet.h>
+
+#include "log.h"
+#include "usb.h"
+#include "client.h"
+#include "device.h"
+
+#define CMD_BUF_SIZE	256
+#define REPLY_BUF_SIZE	1024
+
+enum client_state {
+	CLIENT_COMMAND,		// waiting for command
+	CLIENT_LISTEN,		// listening for devices
+	CLIENT_CONNECTING1,	// issued connection request
+	CLIENT_CONNECTING2,	// connection established, but waiting for response message to get sent
+	CLIENT_CONNECTED,	// connected
+	CLIENT_DEAD
+};
+
+struct mux_client {
+	int fd;
+	unsigned char *ob_buf;
+	int ob_size;
+	int ob_capacity;
+	unsigned char *ib_buf;
+	int ib_size;
+	int ib_capacity;
+	short events, devents;
+	uint32_t connect_tag;
+	int connect_device;
+	enum client_state state;
+};
+
+static struct collection client_list;
+
+int client_read(struct mux_client *client, void *buffer, int len)
+{
+	usbmuxd_log(LL_SPEW, "client_read fd %d buf %p len %d", client->fd, buffer, len);
+	if(client->state != CLIENT_CONNECTED) {
+		usbmuxd_log(LL_ERROR, "Attempted to read from client %d not in CONNECTED state", client->fd);
+		return -1;
+	}
+	return recv(client->fd, buffer, len, 0);
+}
+
+int client_write(struct mux_client *client, void *buffer, int len)
+{
+	usbmuxd_log(LL_SPEW, "client_write fd %d buf %p len %d", client->fd, buffer, len);
+	if(client->state != CLIENT_CONNECTED) {
+		usbmuxd_log(LL_ERROR, "Attempted to write to client %d not in CONNECTED state", client->fd);
+		return -1;
+	}
+	return send(client->fd, buffer, len, 0);
+}
+
+int client_set_events(struct mux_client *client, short events)
+{
+	if((client->state != CLIENT_CONNECTED) && (client->state != CLIENT_CONNECTING2)) {
+		usbmuxd_log(LL_ERROR, "client_set_events to client %d not in CONNECTED state", client->fd);
+		return -1;
+	}
+	client->devents = events;
+	if(client->state == CLIENT_CONNECTED)
+		client->events = events;
+	return 0;
+}
+
+int client_accept(int listenfd)
+{
+	struct sockaddr_un addr;
+	int cfd;
+	socklen_t len = sizeof(struct sockaddr_un);
+	cfd = accept(listenfd, (struct sockaddr *)&addr, &len);
+	if (cfd < 0) {
+		usbmuxd_log(LL_ERROR, "accept() failed (%s)", strerror(errno));
+		return cfd;
+	}
+
+	struct mux_client *client;
+	client = malloc(sizeof(struct mux_client));
+	memset(client, 0, sizeof(struct mux_client));
+
+	client->fd = cfd;
+	client->ob_buf = malloc(REPLY_BUF_SIZE);
+	client->ob_size = 0;
+	client->ob_capacity = REPLY_BUF_SIZE;
+	client->ib_buf = malloc(CMD_BUF_SIZE);
+	client->ib_size = 0;
+	client->ib_capacity = CMD_BUF_SIZE;
+	client->state = CLIENT_COMMAND;
+	client->events = POLLIN;
+
+	collection_add(&client_list, client);
+
+	usbmuxd_log(LL_INFO, "New client on fd %d", client->fd);
+	return client->fd;
+}
+
+void client_close(struct mux_client *client)
+{
+	usbmuxd_log(LL_INFO, "Disconnecting client fd %d", client->fd);
+	if(client->state == CLIENT_CONNECTING1 || client->state == CLIENT_CONNECTING2) {
+		usbmuxd_log(LL_INFO, "Client died mid-connect, aborting device %d connection", client->connect_device);
+		client->state = CLIENT_DEAD;
+		device_abort_connect(client->connect_device, client);
+	}
+	close(client->fd);
+	if(client->ob_buf)
+		free(client->ob_buf);
+	if(client->ib_buf)
+		free(client->ib_buf);
+	collection_remove(&client_list, client);
+	free(client);
+}
+
+void client_get_fds(struct fdlist *list)
+{
+	FOREACH(struct mux_client *client, &client_list) {
+		fdlist_add(list, FD_CLIENT, client->fd, client->events);
+	} ENDFOREACH
+}
+
+static int send_pkt(struct mux_client *client, uint32_t tag, enum usbmuxd_msgtype msg, void *payload, int payload_length)
+{
+	struct usbmuxd_header hdr;
+	hdr.version = USBMUXD_PROTOCOL_VERSION;
+	hdr.length = sizeof(hdr) + payload_length;
+	hdr.message = msg;
+	hdr.tag = tag;
+	usbmuxd_log(LL_DEBUG, "send_pkt fd %d tag %d msg %d payload_length %d", client->fd, tag, msg, payload_length);
+	if((client->ob_capacity - client->ob_size) < hdr.length) {
+		usbmuxd_log(LL_ERROR, "Client %d output buffer full (%d bytes) while sending message %d (%d bytes)", client->fd, client->ob_capacity, hdr.message, hdr.length);
+		client_close(client);
+		return -1;
+	}
+	memcpy(client->ob_buf + client->ob_size, &hdr, sizeof(hdr));
+	if(payload && payload_length)
+		memcpy(client->ob_buf + client->ob_size + sizeof(hdr), payload, payload_length);
+	client->ob_size += hdr.length;
+	client->events |= POLLOUT;
+	return hdr.length;
+}
+
+static int send_result(struct mux_client *client, uint32_t tag, uint32_t result)
+{
+	return send_pkt(client, tag, MESSAGE_RESULT, &result, sizeof(uint32_t));
+}
+
+int client_notify_connect(struct mux_client *client, enum usbmuxd_result result)
+{
+	usbmuxd_log(LL_SPEW, "client_notify_connect fd %d result %d", client->fd, result);
+	if(client->state == CLIENT_DEAD)
+		return -1;
+	if(client->state != CLIENT_CONNECTING1) {
+		usbmuxd_log(LL_ERROR, "client_notify_connect when client %d is not in CONNECTING1 state", client->fd);
+		return -1;
+	}
+	if(send_result(client, client->connect_tag, result) < 0)
+		return -1;
+	if(result == RESULT_OK) {
+		client->state = CLIENT_CONNECTING2;
+		client->events = POLLOUT; // wait for the result packet to go through
+		// no longer need this
+		free(client->ib_buf);
+		client->ib_buf = NULL;
+	} else {
+		client->state = CLIENT_COMMAND;
+	}
+	return 0;
+}
+
+static int notify_device(struct mux_client *client, struct device_info *dev)
+{
+	struct usbmuxd_device_record dmsg;
+	memset(&dmsg, 0, sizeof(dmsg));
+	dmsg.device_id = dev->id;
+	strncpy(dmsg.serial_number, dev->serial, 256);
+	dmsg.serial_number[255] = 0;
+	dmsg.location = dev->location;
+	dmsg.product_id = dev->pid;
+	return send_pkt(client, 0, MESSAGE_DEVICE_ADD, &dmsg, sizeof(dmsg));
+}
+
+static int start_listen(struct mux_client *client)
+{
+	struct device_info *devs;
+	struct device_info *dev;
+	int count, i;
+
+	client->state = CLIENT_LISTEN;
+	count = device_get_count();
+	if(!count)
+		return 0;
+	devs = malloc(sizeof(struct device_info) * count);
+	count = device_get_list(devs);
+
+	// going to need a larger buffer for many devices
+	int needed_buffer = count * (sizeof(struct usbmuxd_device_record) + sizeof(struct usbmuxd_header)) + REPLY_BUF_SIZE;
+	if(client->ob_capacity < needed_buffer) {
+		usbmuxd_log(LL_DEBUG, "Enlarging client %d reply buffer %d -> %d to make space for device notifications", client->fd, client->ob_capacity, needed_buffer);
+		client->ob_buf = realloc(client->ob_buf, needed_buffer);
+		client->ob_capacity = needed_buffer;
+	}
+	dev = devs;
+	for(i=0; i<count; i++) {
+		if(notify_device(client, dev++) < 0) {
+			free(devs);
+			return -1;
+		}
+	}
+	free(devs);
+	return count;
+}
+
+static int client_command(struct mux_client *client, struct usbmuxd_header *hdr, const char *payload)
+{
+	int res;
+	usbmuxd_log(LL_DEBUG, "Client command in fd %d len %d ver %d msg %d tag %d", client->fd, hdr->length, hdr->version, hdr->message, hdr->tag);
+
+	if(client->state != CLIENT_COMMAND) {
+		usbmuxd_log(LL_ERROR, "Client %d command received in the wrong state", client->fd);
+		if(send_result(client, hdr->tag, RESULT_BADCOMMAND) < 0)
+			return -1;
+		client_close(client);
+		return -1;
+	}
+
+	struct usbmuxd_connect_request *ch;
+	switch(hdr->message) {
+		case MESSAGE_LISTEN:
+			if(send_result(client, hdr->tag, 0) < 0)
+				return -1;
+			usbmuxd_log(LL_DEBUG, "Client %d now LISTENING", client->fd);
+			return start_listen(client);
+		case MESSAGE_CONNECT:
+			ch = (void*)payload;
+			usbmuxd_log(LL_DEBUG, "Client %d connection request to device %d port %d", client->fd, ch->device_id, ntohs(ch->port));
+			res = device_start_connect(ch->device_id, ntohs(ch->port), client);
+			if(res < 0) {
+				if(send_result(client, hdr->tag, -res) < 0)
+					return -1;
+			} else {
+				client->connect_tag = hdr->tag;
+				client->connect_device = ch->device_id;
+				client->state = CLIENT_CONNECTING1;
+			}
+			return 0;
+		default:
+			usbmuxd_log(LL_ERROR, "Client %d invalid command %d", client->fd, hdr->message);
+			if(send_result(client, hdr->tag, RESULT_BADCOMMAND) < 0)
+				return -1;
+			return 0;
+	}
+	return -1;
+}
+
+static void process_send(struct mux_client *client)
+{
+	int res;
+	if(!client->ob_size) {
+		usbmuxd_log(LL_WARNING, "Client %d OUT process but nothing to send?", client->fd);
+		client->events &= ~POLLOUT;
+		return;
+	}
+	res = send(client->fd, client->ob_buf, client->ob_size, 0);
+	if(res <= 0) {
+		usbmuxd_log(LL_ERROR, "Send to client fd %d failed: %d %s", client->fd, res, strerror(errno));
+		client_close(client);
+		return;
+	}
+	if(res == client->ob_size) {
+		client->ob_size = 0;
+		client->events &= ~POLLOUT;
+		if(client->state == CLIENT_CONNECTING2) {
+			usbmuxd_log(LL_DEBUG, "Client %d switching to CONNECTED state", client->fd);
+			client->state = CLIENT_CONNECTED;
+			client->events = client->devents;
+			// no longer need this
+			free(client->ob_buf);
+			client->ob_buf = NULL;
+		}
+	} else {
+		client->ob_size -= res;
+		memmove(client->ob_buf, client->ob_buf + res, client->ob_size);
+	}
+}
+static void process_recv(struct mux_client *client)
+{
+	int res;
+	int did_read = 0;
+	if(client->ib_size < sizeof(struct usbmuxd_header)) {
+		res = recv(client->fd, client->ib_buf + client->ib_size, sizeof(struct usbmuxd_header) - client->ib_size, 0);
+		if(res <= 0) {
+			if(res < 0)
+				usbmuxd_log(LL_ERROR, "Receive from client fd %d failed: %s", client->fd, strerror(errno));
+			else
+				usbmuxd_log(LL_INFO, "Client %d connection closed", client->fd);
+			client_close(client);
+			return;
+		}
+		client->ib_size += res;
+		if(client->ib_size < sizeof(struct usbmuxd_header))
+			return;
+		did_read = 1;
+	}
+	struct usbmuxd_header *hdr = (void*)client->ib_buf;
+	if(hdr->version != USBMUXD_PROTOCOL_VERSION) {
+		usbmuxd_log(LL_INFO, "Client %d version mismatch: expected %d, got %d", client->fd, USBMUXD_PROTOCOL_VERSION, hdr->version);
+		client_close(client);
+	}
+	if(hdr->length > client->ib_capacity) {
+		usbmuxd_log(LL_INFO, "Client %d message is too long (%d bytes)", client->fd, hdr->length);
+		client_close(client);
+	}
+	if(hdr->length < sizeof(struct usbmuxd_header)) {
+		usbmuxd_log(LL_ERROR, "Client %d message is too short (%d bytes)", client->fd, hdr->length);
+		client_close(client);
+	}
+	if(client->ib_size < hdr->length) {
+		if(did_read)
+			return; //maybe we would block, so defer to next loop
+		res = recv(client->fd, client->ib_buf + client->ib_size, hdr->length - client->ib_size, 0);
+		if(res < 0) {
+			usbmuxd_log(LL_ERROR, "Receive from client fd %d failed: %s", client->fd, strerror(errno));
+			client_close(client);
+			return;
+		} else if(res == 0) {
+			usbmuxd_log(LL_INFO, "Client %d connection closed", client->fd);
+			client_close(client);
+			return;
+		}
+		client->ib_size += res;
+		if(client->ib_size < hdr->length)
+			return;
+	}
+	client_command(client, hdr, (char *)(hdr+1));
+	client->ib_size = 0;
+}
+
+void client_process(int fd, short events)
+{
+	struct mux_client *client = NULL;
+	FOREACH(struct mux_client *lc, &client_list) {
+		if(lc->fd == fd) {
+			client = lc;
+			break;
+		}
+	} ENDFOREACH
+
+	if(!client) {
+		usbmuxd_log(LL_ERROR, "client_process: fd %d not found in client list", fd);
+		return;
+	}
+
+	if(client->state == CLIENT_CONNECTED) {
+		usbmuxd_log(LL_SPEW, "client_process in CONNECTED state");
+		device_client_process(client->connect_device, client, events);
+	} else {
+		if(events & POLLIN) {
+			process_recv(client);
+		} else if(events & POLLOUT) { //not both in case client died as part of process_recv
+			process_send(client);
+		}
+	}
+
+}
+
+void client_device_add(struct device_info *dev)
+{
+	usbmuxd_log(LL_DEBUG, "client_device_add: id %d, location 0x%x, serial %s", dev->id, dev->location, dev->serial);
+	FOREACH(struct mux_client *client, &client_list) {
+		if(client->state == CLIENT_LISTEN)
+			notify_device(client, dev);
+	} ENDFOREACH
+}
+void client_device_remove(int device_id)
+{
+	uint32_t id = device_id;
+	usbmuxd_log(LL_DEBUG, "client_device_remove: id %d", device_id);
+	FOREACH(struct mux_client *client, &client_list) {
+		if(client->state == CLIENT_LISTEN)
+			send_pkt(client, 0, MESSAGE_DEVICE_REMOVE, &id, sizeof(uint32_t));
+	} ENDFOREACH
+}
+
+
+void client_init(void)
+{
+	usbmuxd_log(LL_DEBUG, "client_init");
+	collection_init(&client_list);
+}
+
+void client_shutdown(void)
+{
+	usbmuxd_log(LL_DEBUG, "client_shutdown");
+	FOREACH(struct mux_client *client, &client_list) {
+		client_close(client);
+	} ENDFOREACH
+	collection_free(&client_list);
+}
diff --git a/daemon/client.h b/daemon/client.h
new file mode 100644
index 0000000..4fc1ab4
--- /dev/null
+++ b/daemon/client.h
@@ -0,0 +1,46 @@
+/*
+	usbmuxd - iPhone/iPod Touch USB multiplex server daemon
+
+Copyright (C) 2009	Hector Martin "marcan" <hector@marcansoft.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 or version 3.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#ifndef __CLIENT_H__
+#define __CLIENT_H__
+
+#include <stdint.h>
+#include "usbmuxd-proto.h"
+
+struct device_info;
+struct mux_client;
+
+int client_read(struct mux_client *client, void *buffer, int len);
+int client_write(struct mux_client *client, void *buffer, int len);
+int client_set_events(struct mux_client *client, short events);
+void client_close(struct mux_client *client);
+int client_notify_connect(struct mux_client *client, enum usbmuxd_result result);
+
+void client_device_add(struct device_info *dev);
+void client_device_remove(int device_id);
+
+int client_accept(int fd);
+void client_get_fds(struct fdlist *list);
+void client_process(int fd, short events);
+
+void client_init(void);
+void client_shutdown(void);
+
+#endif
diff --git a/daemon/device.c b/daemon/device.c
new file mode 100644
index 0000000..3a5883c
--- /dev/null
+++ b/daemon/device.c
@@ -0,0 +1,751 @@
+/*
+	usbmuxd - iPhone/iPod Touch USB multiplex server daemon
+
+Copyright (C) 2009	Hector Martin "marcan" <hector@marcansoft.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 or version 3.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#define _BSD_SOURCE
+
+#ifdef HAVE_CONFIG_H
+#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 30
+
+enum mux_protocol {
+	MUX_PROTO_VERSION = 0,
+	MUX_PROTO_TCP = IPPROTO_TCP,
+};
+
+enum mux_dev_state {
+	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_REFUSED,		// RST received during SYN
+	CONN_DYING,			// RST received
+	CONN_DEAD			// being freed; used to prevent infinite recursion between client<->device freeing
+};
+
+struct mux_header
+{
+	uint32_t protocol;
+	uint32_t length;
+};
+
+struct version_header
+{
+	uint32_t major;
+	uint32_t minor;
+	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 struct collection device_list;
+
+uint64_t mstime64(void)
+{
+	struct timeval tv;
+	gettimeofday(&tv, NULL);
+	return tv.tv_sec * 1000 + tv.tv_usec / 1000;
+}
+
+static int get_next_device_id(void)
+{
+	while(1) {
+		int ok = 1;
+		FOREACH(struct mux_device *dev, &device_list) {
+			if(dev->id == next_device_id) {
+				next_device_id++;
+				ok = 0;
+				break;
+			}
+		} ENDFOREACH
+		if(ok)
+			return next_device_id++;
+	}
+}
+
+static int send_packet(struct mux_device *dev, enum mux_protocol proto, void *header, const void *data, int length)
+{
+	unsigned char *buffer;
+	int hdrlen;
+	int res;
+
+	switch(proto) {
+		case MUX_PROTO_VERSION:
+			hdrlen = sizeof(struct version_header);
+			break;
+		case MUX_PROTO_TCP:
+			hdrlen = sizeof(struct tcphdr);
+			break;
+		default:
+			usbmuxd_log(LL_ERROR, "Invalid protocol %d for outgoing packet (dev %d hdr %p data %p len %d)", proto, dev->id, header, data, length);
+			return -1;
+	}
+	usbmuxd_log(LL_SPEW, "send_packet(%d, 0x%x, %p, %p, %d)", dev->id, proto, header, data, length);
+
+	int total = sizeof(struct mux_header) + hdrlen + length;
+
+	if(total > USB_MTU) {
+		usbmuxd_log(LL_ERROR, "Tried to send packet larger than USB MTU (hdr %d data %d total %d) to device %d", hdrlen, length, total, dev->id);
+		return -1;
+	}
+
+	buffer = malloc(total);
+	struct mux_header *mhdr = (struct mux_header *)buffer;
+	mhdr->protocol = htonl(proto);
+	mhdr->length = htonl(total);;
+	memcpy(buffer + sizeof(struct mux_header), header, hdrlen);
+	if(data && length)
+		memcpy(buffer + sizeof(struct mux_header) + hdrlen, data, length);
+
+	if((res = usb_send(dev->usbdev, buffer, total)) < 0) {
+		usbmuxd_log(LL_ERROR, "usb_send failed while sending packet (len %d) to device %d: %d", total, dev->id, res);
+		free(buffer);
+		return res;
+	}
+	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_anon_rst(struct mux_device *dev, uint16_t sport, uint16_t dport, uint32_t ack)
+{
+	struct tcphdr th;
+	memset(&th, 0, sizeof(th));
+	th.th_sport = htons(sport);
+	th.th_dport = htons(dport);
+	th.th_ack = htonl(ack);
+	th.th_flags = TH_RST;
+	th.th_off = sizeof(th) / 4;
+
+	usbmuxd_log(LL_DEBUG, "[OUT] dev=%d sport=%d dport=%d flags=0x%x", dev->id, sport, dport, th.th_flags);
+
+	int res = send_packet(dev, MUX_PROTO_TCP, &th, NULL, 0);
+	return res;
+}
+
+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 && conn->state != CONN_REFUSED) {
+		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_REFUSED || 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)
+{
+	if(dev->state != MUXDEV_INIT) {
+		usbmuxd_log(LL_WARNING, "Version packet from already initialized device %d", dev->id);
+		return;
+	}
+	vh->major = ntohl(vh->major);
+	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);
+		if(!(th->th_flags & TH_RST)) {
+			if(send_anon_rst(dev, sport, dport, ntohl(th->th_seq)) < 0)
+				usbmuxd_log(LL_ERROR, "Error sending TCP RST to device %d (%d->%d)", conn->dev->id, sport, dport);
+		}
+		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_REFUSED;
+			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)
+{
+	struct mux_device *dev = NULL;
+	FOREACH(struct mux_device *tdev, &device_list) {
+		if(tdev->usbdev == usbdev) {
+			dev = tdev;
+			break;
+		}
+	} 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;
+
+	if(ntohl(mhdr->length) != length) {
+		usbmuxd_log(LL_ERROR, "Incoming packet size mismatch (dev %d, expected %d, got %d)", dev->id, ntohl(mhdr->length), length);
+		return;
+	}
+
+	struct tcphdr *th;
+	unsigned char *payload;
+	int payload_length;
+
+	switch(ntohl(mhdr->protocol)) {
+		case MUX_PROTO_VERSION:
+			device_version_input(dev, (struct version_header *)(mhdr+1));
+			break;
+		case MUX_PROTO_TCP:
+			th = (struct tcphdr *)(mhdr+1);
+			payload = (unsigned char *)(th+1);
+			payload_length = length - sizeof(struct tcphdr) - sizeof(struct mux_header);
+			device_tcp_input(dev, (struct tcphdr *)(mhdr+1), payload, payload_length);
+			break;
+		default:
+			usbmuxd_log(LL_ERROR, "Incoming packet for device %d has unknown protocol 0x%x)", dev->id, ntohl(mhdr->protocol));
+			break;
+	}
+
+}
+
+int device_add(struct usb_device *usbdev)
+{
+	int res;
+	int id = get_next_device_id();
+	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(dev, MUX_PROTO_VERSION, &vh, NULL, 0)) < 0) {
+		usbmuxd_log(LL_ERROR, "Error sending version request packet to device %d\n", id);
+		free(dev);
+		return res;
+	}
+	collection_add(&device_list, dev);
+	return 0;
+}
+
+void device_remove(struct usb_device *usbdev)
+{
+	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;
+		}
+	} 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");
+	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)
+{
+	usbmuxd_log(LL_DEBUG, "device_shutdown");
+	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);
+}
diff --git a/daemon/device.h b/daemon/device.h
new file mode 100644
index 0000000..ce6c50b
--- /dev/null
+++ b/daemon/device.h
@@ -0,0 +1,52 @@
+/*
+	usbmuxd - iPhone/iPod Touch USB multiplex server daemon
+
+Copyright (C) 2009	Hector Martin "marcan" <hector@marcansoft.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 or version 3.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#ifndef __DEVICE_H__
+#define __DEVICE_H__
+
+#include "usb.h"
+#include "client.h"
+
+struct device_info {
+	int id;
+	const char *serial;
+	uint32_t location;
+	uint16_t pid;
+};
+
+void device_data_input(struct usb_device *dev, unsigned char *buf, int length);
+
+int device_add(struct usb_device *dev);
+void device_remove(struct usb_device *dev);
+
+int device_start_connect(int device_id, uint16_t port, struct mux_client *client);
+void device_client_process(int device_id, struct mux_client *client, short events);
+void device_abort_connect(int device_id, struct mux_client *client);
+
+int device_get_count(void);
+int device_get_list(struct device_info *p);
+
+int device_get_timeout(void);
+void device_check_timeouts(void);
+
+void device_init(void);
+void device_kill_connections(void);
+void device_shutdown(void);
+#endif
diff --git a/daemon/log.c b/daemon/log.c
new file mode 100644
index 0000000..2ccb3cc
--- /dev/null
+++ b/daemon/log.c
@@ -0,0 +1,94 @@
+/*
+	usbmuxd - iPhone/iPod Touch USB multiplex server daemon
+
+Copyright (C) 2009	Hector Martin "marcan" <hector@marcansoft.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 or version 3.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <time.h>
+#include <sys/time.h>
+#include <syslog.h>
+
+#include "log.h"
+
+int log_level = LL_WARNING;
+
+int log_syslog = 0;
+
+void log_enable_syslog()
+{
+	if (!log_syslog) {
+		openlog("usbmuxd", LOG_PID, 0);
+		log_syslog = 1;
+	}
+}
+
+void log_disable_syslog()
+{
+	if (log_syslog) {
+		closelog();
+	}
+}
+
+static int level_to_syslog_level(int level)
+{
+	int result = level + LOG_CRIT;
+	if (result > LOG_DEBUG) {
+		result = LOG_DEBUG;
+	}
+	return result;
+}
+
+void usbmuxd_log(enum loglevel level, const char *fmt, ...)
+{
+	va_list ap;
+	char *fs;
+	struct timeval ts;
+	struct tm *tp;
+
+	gettimeofday(&ts, NULL);
+	tp = localtime(&ts.tv_sec);
+
+	if(level > log_level)
+		return;
+
+	fs = malloc(20 + strlen(fmt));
+
+	if(log_syslog) {
+		sprintf(fs, "[%d] %s\n", level, fmt);
+	} else {
+		strftime(fs, 10, "[%H:%M:%S", tp);
+		sprintf(fs+9, ".%03d][%d] %s\n", (int)(ts.tv_usec / 1000), level, fmt);
+	}
+
+	va_start(ap, fmt);
+	if (log_syslog) {
+		vsyslog(level_to_syslog_level(level), fs, ap);
+	} else {
+		vfprintf(stderr, fs, ap);
+	}
+	va_end(ap);
+
+	free(fs);
+}
diff --git a/daemon/log.h b/daemon/log.h
new file mode 100644
index 0000000..4a2ac2e
--- /dev/null
+++ b/daemon/log.h
@@ -0,0 +1,43 @@
+/*
+	usbmuxd - iPhone/iPod Touch USB multiplex server daemon
+
+Copyright (C) 2009	Hector Martin "marcan" <hector@marcansoft.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 or version 3.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#ifndef __LOG_H__
+#define __LOG_H__
+
+enum loglevel {
+	LL_FATAL = 0,
+	LL_ERROR,
+	LL_WARNING,
+	LL_NOTICE,
+	LL_INFO,
+	LL_DEBUG,
+	LL_SPEW,
+	LL_FLOOD,
+};
+
+extern int log_level;
+
+void log_enable_syslog();
+void log_disable_syslog();
+
+void usbmuxd_log(enum loglevel level, const char *fmt, ...) __attribute__ ((format (printf, 2, 3)));
+
+
+#endif
diff --git a/daemon/main.c b/daemon/main.c
new file mode 100644
index 0000000..dde99c2
--- /dev/null
+++ b/daemon/main.c
@@ -0,0 +1,548 @@
+/*
+	usbmuxd - iPhone/iPod Touch USB multiplex server daemon
+
+Copyright (C) 2009	Hector Martin "marcan" <hector@marcansoft.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 or version 3.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#define _BSD_SOURCE
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <pwd.h>
+#include <grp.h>
+
+#include "log.h"
+#include "usb.h"
+#include "device.h"
+#include "client.h"
+
+static const char *socket_path = "/var/run/usbmuxd";
+static const char *lockfile = "/var/run/usbmuxd.pid";
+
+int should_exit;
+
+static int verbose = 0;
+static int foreground = 0;
+static int drop_privileges = 0;
+static const char *drop_user = "usbmux";
+static int opt_udev = 0;
+static int opt_exit = 0;
+static int exit_signal = 0;
+static int daemon_pipe;
+
+static int report_to_parent = 0;
+
+int create_socket(void) {
+	struct sockaddr_un bind_addr;
+	int listenfd;
+
+	if(unlink(socket_path) == -1 && errno != ENOENT) {
+		usbmuxd_log(LL_FATAL, "unlink(%s) failed: %s", socket_path, strerror(errno));
+		return -1;
+	}
+
+	listenfd = socket(AF_UNIX, SOCK_STREAM, 0);
+	if (listenfd == -1) {
+		usbmuxd_log(LL_FATAL, "socket() failed: %s", strerror(errno));
+		return -1;
+	}
+
+	bzero(&bind_addr, sizeof(bind_addr));
+	bind_addr.sun_family = AF_UNIX;
+	strcpy(bind_addr.sun_path, socket_path);
+	if (bind(listenfd, (struct sockaddr*)&bind_addr, sizeof(bind_addr)) != 0) {
+		usbmuxd_log(LL_FATAL, "bind() failed: %s", strerror(errno));
+		return -1;
+	}
+
+	// Start listening
+	if (listen(listenfd, 5) != 0) {
+		usbmuxd_log(LL_FATAL, "listen() failed: %s", strerror(errno));
+		return -1;
+	}
+
+	chmod(socket_path, 0666);
+
+	return listenfd;
+}
+
+void handle_signal(int sig)
+{
+	if (sig != SIGUSR1) {
+		usbmuxd_log(LL_NOTICE,"Caught signal %d, exiting", sig);
+		should_exit = 1;
+	} else {
+		if(opt_udev) {
+			usbmuxd_log(LL_INFO, "Caught SIGUSR1, checking if we can terminate (no more devices attached)...");
+			if (device_get_count() > 0) {
+				// we can't quit, there are still devices attached.
+				usbmuxd_log(LL_NOTICE, "Refusing to terminate, there are still devices attached. Kill me with signal 15 (TERM) to force quit.");
+			} else {
+				// it's safe to quit
+				should_exit = 1;
+			}
+		} else {
+			usbmuxd_log(LL_INFO, "Caught SIGUSR1 but we weren't started in --udev mode, ignoring");
+		}
+	}
+}
+
+void set_signal_handlers(void)
+{
+	struct sigaction sa;
+	memset(&sa, 0, sizeof(struct sigaction));
+	sa.sa_handler = handle_signal;
+	sigaction(SIGINT, &sa, NULL);
+	sigaction(SIGQUIT, &sa, NULL);
+	sigaction(SIGTERM, &sa, NULL);
+	sigaction(SIGUSR1, &sa, NULL);
+}
+
+int main_loop(int listenfd)
+{
+	int to, cnt, i, dto;
+	struct fdlist pollfds;
+
+	while(!should_exit) {
+		usbmuxd_log(LL_FLOOD, "main_loop iteration");
+		to = usb_get_timeout();
+		usbmuxd_log(LL_FLOOD, "USB timeout is %d ms", to);
+		dto = device_get_timeout();
+		usbmuxd_log(LL_FLOOD, "Device timeout is %d ms", to);
+		if(dto < to)
+			to = dto;
+
+		fdlist_create(&pollfds);
+		fdlist_add(&pollfds, FD_LISTEN, listenfd, POLLIN);
+		usb_get_fds(&pollfds);
+		client_get_fds(&pollfds);
+		usbmuxd_log(LL_FLOOD, "fd count is %d", pollfds.count);
+
+		cnt = poll(pollfds.fds, pollfds.count, to);
+		usbmuxd_log(LL_FLOOD, "poll() returned %d", cnt);
+
+		if(cnt == -1) {
+			if(errno == EINTR && should_exit) {
+				usbmuxd_log(LL_INFO, "event processing interrupted");
+				fdlist_free(&pollfds);
+				return 0;
+			}
+		} else if(cnt == 0) {
+			if(usb_process() < 0) {
+				usbmuxd_log(LL_FATAL, "usb_process() failed");
+				fdlist_free(&pollfds);
+				return -1;
+			}
+			device_check_timeouts();
+		} else {
+			int done_usb = 0;
+			for(i=0; i<pollfds.count; i++) {
+				if(pollfds.fds[i].revents) {
+					if(!done_usb && pollfds.owners[i] == FD_USB) {
+						if(usb_process() < 0) {
+							usbmuxd_log(LL_FATAL, "usb_process() failed");
+							fdlist_free(&pollfds);
+							return -1;
+						}
+						done_usb = 1;
+					}
+					if(pollfds.owners[i] == FD_LISTEN) {
+						if(client_accept(listenfd) < 0) {
+							usbmuxd_log(LL_FATAL, "client_accept() failed");
+							fdlist_free(&pollfds);
+							return -1;
+						}
+					}
+					if(pollfds.owners[i] == FD_CLIENT) {
+						client_process(pollfds.fds[i].fd, pollfds.fds[i].revents);
+					}
+				}
+			}
+		}
+		fdlist_free(&pollfds);
+	}
+	return 0;
+}
+
+/**
+ * make this program run detached from the current console
+ */
+static int daemonize(void)
+{
+	pid_t pid;
+	pid_t sid;
+	int pfd[2];
+	int res;
+
+	// already a daemon
+	if (getppid() == 1)
+		return 0;
+
+	if((res = pipe(pfd)) < 0) {
+		usbmuxd_log(LL_FATAL, "pipe() failed.");
+		return res;
+	}
+
+	pid = fork();
+	if (pid < 0) {
+		usbmuxd_log(LL_FATAL, "fork() failed.");
+		return pid;
+	}
+
+	if (pid > 0) {
+		// exit parent process
+		int status;
+		close(pfd[1]);
+
+		if((res = read(pfd[0],&status,sizeof(int))) != sizeof(int)) {
+			fprintf(stderr, "usbmuxd: ERROR: Failed to get init status from child, check syslog for messages.\n");
+			exit(1);
+		}
+		if(status != 0)
+			fprintf(stderr, "usbmuxd: ERROR: Child process exited with error %d, check syslog for messages.\n", status);
+		exit(status);
+	}
+	// At this point we are executing as the child process
+	// but we need to do one more fork
+
+	daemon_pipe = pfd[1];
+	close(pfd[0]);
+	report_to_parent = 1;
+
+	// Change the file mode mask
+	umask(0);
+
+	// Create a new SID for the child process
+	sid = setsid();
+	if (sid < 0) {
+		usbmuxd_log(LL_FATAL, "setsid() failed.");
+		return -1;
+	}
+
+	pid = fork();
+	if (pid < 0) {
+		usbmuxd_log(LL_FATAL, "fork() failed (second).");
+		return pid;
+	}
+
+	if (pid > 0) {
+		// exit parent process
+		close(daemon_pipe);
+		exit(0);
+	}
+
+	// Change the current working directory.
+	if ((chdir("/")) < 0) {
+		usbmuxd_log(LL_FATAL, "chdir() failed");
+		return -2;
+	}
+	// Redirect standard files to /dev/null
+	if (!freopen("/dev/null", "r", stdin)) {
+		usbmuxd_log(LL_FATAL, "Redirection of stdin failed.");
+		return -3;
+	}
+	if (!freopen("/dev/null", "w", stdout)) {
+		usbmuxd_log(LL_FATAL, "Redirection of stdout failed.");
+		return -3;
+	}
+
+	return 0;
+}
+
+static int notify_parent(int status)
+{
+	int res;
+
+	report_to_parent = 0;
+	if ((res = write(daemon_pipe, &status, sizeof(int))) != sizeof(int)) {
+		usbmuxd_log(LL_FATAL, "Could not notify parent!");
+		if(res >= 0)
+			return -2;
+		else
+			return res;
+	}
+	close(daemon_pipe);
+	if (!freopen("/dev/null", "w", stderr)) {
+		usbmuxd_log(LL_FATAL, "Redirection of stderr failed.");
+		return -1;
+	}
+	return 0;
+}
+
+static void usage()
+{
+	printf("usage: usbmuxd [options]\n");
+	printf("\t-h|--help                 Print this message.\n");
+	printf("\t-v|--verbose              Be verbose (use twice or more to increase).\n");
+	printf("\t-f|--foreground           Do not daemonize (implies one -v).\n");
+	printf("\t-U|--user[=USER]          Change to this user after startup (needs usb privileges).\n");
+	printf("\t                          If USER is not specified, defaults to usbmux.\n");
+	printf("\t-u|--udev                 Run in udev operation mode.\n");
+	printf("\t-x|--exit                 Tell a running instance to exit if there are no devices\n");
+	printf("\t                          connected (must be in udev mode).\n");
+	printf("\t-X|--force-exit           Tell a running instance to exit, even if there are still\n");
+	printf("\t                          devices connected (always works).\n");
+	printf("\n");
+}
+
+static void parse_opts(int argc, char **argv)
+{
+	static struct option longopts[] = {
+		{"help", 0, NULL, 'h'},
+		{"foreground", 0, NULL, 'f'},
+		{"verbose", 0, NULL, 'v'},
+		{"user", 2, NULL, 'U'},
+		{"udev", 0, NULL, 'u'},
+		{"exit", 0, NULL, 'x'},
+		{"force-exit", 0, NULL, 'X'},
+		{NULL, 0, NULL, 0}
+	};
+	int c;
+
+	while (1) {
+		c = getopt_long(argc, argv, "hfvuU::xX", longopts, (int *) 0);
+		if (c == -1) {
+			break;
+		}
+
+		switch (c) {
+		case 'h':
+			usage();
+			exit(0);
+		case 'f':
+			foreground = 1;
+			break;
+		case 'v':
+			++verbose;
+			break;
+		case 'U':
+			drop_privileges = 1;
+			if(optarg)
+				drop_user = optarg;
+			break;
+		case 'u':
+			opt_udev = 1;
+			break;
+		case 'x':
+			opt_exit = 1;
+			exit_signal = SIGUSR1;
+			break;
+		case 'X':
+			opt_exit = 1;
+			exit_signal = SIGTERM;
+			break;
+		default:
+			usage();
+			exit(2);
+		}
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	int listenfd;
+	int res = 0;
+	int lfd;
+	struct flock lock;
+	char pids[10];
+
+	parse_opts(argc, argv);
+
+	argc -= optind;
+	argv += optind;
+
+	if (!foreground) {
+		verbose += LL_WARNING;
+		log_enable_syslog();
+	} else {
+		verbose += LL_NOTICE;
+	}
+
+	/* set log level to specified verbosity */
+	log_level = verbose;
+
+	usbmuxd_log(LL_NOTICE, "usbmux v0.1 starting up");
+	should_exit = 0;
+
+	set_signal_handlers();
+
+	res = lfd = open(lockfile, O_WRONLY|O_CREAT, 0644);
+	if(res == -1) {
+		usbmuxd_log(LL_FATAL, "Could not open lockfile");
+		goto terminate;
+	}
+	lock.l_type = F_WRLCK;
+	lock.l_whence = SEEK_SET;
+	lock.l_start = 0;
+	lock.l_len = 0;
+	fcntl(lfd, F_GETLK, &lock);
+	close(lfd);
+	if (lock.l_type != F_UNLCK) {
+		if (opt_exit) {
+			if (lock.l_pid && !kill(lock.l_pid, 0)) {
+				usbmuxd_log(LL_NOTICE, "Sending signal %d to instance with pid %d", exit_signal, lock.l_pid);
+				res = 0;
+				if (kill(lock.l_pid, exit_signal) < 0) {
+					usbmuxd_log(LL_FATAL, "Could not deliver signal %d to pid %d", exit_signal, lock.l_pid);
+					res = -1;
+				}
+				goto terminate;
+			} else {
+				usbmuxd_log(LL_ERROR, "Could not determine pid of the other running instance!");
+				res = -1;
+				goto terminate;
+			}
+		} else {
+			if (!opt_udev) {
+				usbmuxd_log(LL_ERROR, "Another instance is already running (pid %d). exiting.", lock.l_pid);
+				res = -1;
+			} else {
+				usbmuxd_log(LL_NOTICE, "Another instance is already running (pid %d). exiting.", lock.l_pid);
+				res = 0;
+			}
+			goto terminate;
+		}
+	}
+	unlink(lockfile);
+
+	if (opt_exit) {
+		usbmuxd_log(LL_NOTICE, "No running instance found, none killed. exiting.");
+		goto terminate;
+	}
+
+	if (!foreground) {
+		if ((res = daemonize()) < 0) {
+			fprintf(stderr, "usbmuxd: FATAL: Could not daemonize!\n");
+			usbmuxd_log(LL_FATAL, "Could not daemonize!");
+			goto terminate;
+		}
+	}
+
+	// now open the lockfile and place the lock
+	res = lfd = open(lockfile, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, 0644);
+	if(res < 0) {
+		usbmuxd_log(LL_FATAL, "Could not open lockfile");
+		goto terminate;
+	}
+	lock.l_type = F_WRLCK;
+	lock.l_whence = SEEK_SET;
+	lock.l_start = 0;
+	lock.l_len = 0;
+	if ((res = fcntl(lfd, F_SETLK, &lock)) < 0) {
+		usbmuxd_log(LL_FATAL, "Lockfile locking failed!");
+		goto terminate;
+	}
+	sprintf(pids, "%d", getpid());
+	if ((res = write(lfd, pids, strlen(pids))) != strlen(pids)) {
+		usbmuxd_log(LL_FATAL, "Could not write pidfile!");
+		if(res >= 0)
+			res = -2;
+		goto terminate;
+	}
+
+	usbmuxd_log(LL_INFO, "Creating socket");
+	res = listenfd = create_socket();
+	if(listenfd < 0)
+		goto terminate;
+
+	// drop elevated privileges
+	if (drop_privileges && (getuid() == 0 || geteuid() == 0)) {
+		struct passwd *pw = getpwnam(drop_user);
+		if (!pw) {
+			usbmuxd_log(LL_FATAL, "Dropping privileges failed, check if user '%s' exists!", drop_user);
+			res = -1;
+			goto terminate;
+		}
+
+		if ((res = initgroups(drop_user, pw->pw_gid)) < 0) {
+			usbmuxd_log(LL_FATAL, "Failed to drop privileges (cannot set supplementary groups)");
+			goto terminate;
+		}
+		if ((res = setgid(pw->pw_gid)) < 0) {
+			usbmuxd_log(LL_FATAL, "Failed to drop privileges (cannot set group ID to %d)", pw->pw_gid);
+			goto terminate;
+		}
+		if ((res = setuid(pw->pw_uid)) < 0) {
+			usbmuxd_log(LL_FATAL, "Failed to drop privileges (cannot set user ID to %d)", pw->pw_uid);
+			goto terminate;
+		}
+
+		// security check
+		if (setuid(0) != -1) {
+			usbmuxd_log(LL_FATAL, "Failed to drop privileges properly!");
+			res = -1;
+			goto terminate;
+		}
+		if (getuid() != pw->pw_uid || getgid() != pw->pw_gid) {
+			usbmuxd_log(LL_FATAL, "Failed to drop privileges properly!");
+			res = -1;
+			goto terminate;
+		}
+		usbmuxd_log(LL_NOTICE, "Successfully dropped privileges to '%s'", drop_user);
+	}
+
+	client_init();
+	device_init();
+	usbmuxd_log(LL_INFO, "Initializing USB");
+	if((res = usb_init()) < 0)
+		goto terminate;
+
+	usbmuxd_log(LL_INFO, "%d device%s detected", res, (res==1)?"":"s");
+
+	usbmuxd_log(LL_NOTICE, "Initialization complete");
+
+	if (report_to_parent)
+		if((res = notify_parent(0)) < 0)
+			goto terminate;
+
+	res = main_loop(listenfd);
+	if(res < 0)
+		usbmuxd_log(LL_FATAL, "main_loop failed");
+
+	usbmuxd_log(LL_NOTICE, "usbmux shutting down");
+	device_kill_connections();
+	usb_shutdown();
+	device_shutdown();
+	client_shutdown();
+	usbmuxd_log(LL_NOTICE, "Shutdown complete");
+
+terminate:
+	log_disable_syslog();
+
+	if (res < 0)
+		res = -res;
+	else
+		res = 0;
+	if (report_to_parent)
+		notify_parent(res);
+
+	return res;
+}
diff --git a/daemon/usb-linux.c b/daemon/usb-linux.c
new file mode 100644
index 0000000..c09cdc9
--- /dev/null
+++ b/daemon/usb-linux.c
@@ -0,0 +1,542 @@
+/*
+	usbmuxd - iPhone/iPod Touch USB multiplex server daemon
+
+Copyright (C) 2009	Hector Martin "marcan" <hector@marcansoft.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 or version 3.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <libusb.h>
+
+#include "usb.h"
+#include "log.h"
+#include "device.h"
+
+// interval for device connection/disconnection polling, in milliseconds
+// we need this because there is currently no asynchronous device discovery mechanism in libusb
+#define DEVICE_POLL_TIME 1000
+
+struct usb_device {
+	libusb_device_handle *dev;
+	uint8_t bus, address;
+	uint16_t vid, pid;
+	char serial[256];
+	int alive;
+	struct libusb_transfer *rx_xfer;
+	struct collection tx_xfers;
+	int wMaxPacketSize;
+};
+
+static struct collection device_list;
+
+static struct timeval next_dev_poll_time;
+
+static int devlist_failures;
+
+static void usb_disconnect(struct usb_device *dev)
+{
+	if(!dev->dev) {
+		return;
+	}
+
+	// kill the rx xfer and tx xfers and try to make sure the callbacks get called before we free the device
+	if(dev->rx_xfer) {
+		usbmuxd_log(LL_DEBUG, "usb_disconnect: cancelling RX xfer");
+		libusb_cancel_transfer(dev->rx_xfer);
+	}
+	FOREACH(struct libusb_transfer *xfer, &dev->tx_xfers) {
+		usbmuxd_log(LL_DEBUG, "usb_disconnect: cancelling TX xfer %p", xfer);
+		libusb_cancel_transfer(xfer);
+	} ENDFOREACH
+
+	while(dev->rx_xfer || collection_count(&dev->tx_xfers)) {
+		struct timeval tv;
+		int res;
+
+		tv.tv_sec = 0;
+		tv.tv_usec = 1000;
+		if((res = libusb_handle_events_timeout(NULL, &tv)) < 0) {
+			usbmuxd_log(LL_ERROR, "libusb_handle_events_timeout for usb_disconnect failed: %d", res);
+			break;
+		}
+	}
+	collection_free(&dev->tx_xfers);
+	libusb_release_interface(dev->dev, USB_INTERFACE);
+	libusb_close(dev->dev);
+	dev->dev = NULL;
+	collection_remove(&device_list, dev);
+	free(dev);
+}
+
+static void tx_callback(struct libusb_transfer *xfer)
+{
+	struct usb_device *dev = xfer->user_data;
+	usbmuxd_log(LL_SPEW, "TX callback dev %d-%d len %d -> %d status %d", dev->bus, dev->address, xfer->length, xfer->actual_length, xfer->status);
+	if(xfer->status != LIBUSB_TRANSFER_COMPLETED) {
+		switch(xfer->status) {
+			case LIBUSB_TRANSFER_COMPLETED: //shut up compiler
+			case LIBUSB_TRANSFER_ERROR:
+				// funny, this happens when we disconnect the device while waiting for a transfer, sometimes
+				usbmuxd_log(LL_INFO, "Device %d-%d TX aborted due to error or disconnect", dev->bus, dev->address);
+				break;
+			case LIBUSB_TRANSFER_TIMED_OUT:
+				usbmuxd_log(LL_ERROR, "TX transfer timed out for device %d-%d", dev->bus, dev->address);
+				break;
+			case LIBUSB_TRANSFER_CANCELLED:
+				usbmuxd_log(LL_DEBUG, "Device %d-%d TX transfer cancelled", dev->bus, dev->address);
+				break;
+			case LIBUSB_TRANSFER_STALL:
+				usbmuxd_log(LL_ERROR, "TX transfer stalled for device %d-%d", dev->bus, dev->address);
+				break;
+			case LIBUSB_TRANSFER_NO_DEVICE:
+				// other times, this happens, and also even when we abort the transfer after device removal
+				usbmuxd_log(LL_INFO, "Device %d-%d TX aborted due to disconnect", dev->bus, dev->address);
+				break;
+			case LIBUSB_TRANSFER_OVERFLOW:
+				usbmuxd_log(LL_ERROR, "TX transfer overflow for device %d-%d", dev->bus, dev->address);
+				break;
+			// and nothing happens (this never gets called) if the device is freed after a disconnect! (bad)
+		}
+		// we can't usb_disconnect here due to a deadlock, so instead mark it as dead and reap it after processing events
+		// we'll do device_remove there too
+		dev->alive = 0;
+	}
+	if(xfer->buffer)
+		free(xfer->buffer);
+	collection_remove(&dev->tx_xfers, xfer);
+	libusb_free_transfer(xfer);
+}
+
+int usb_send(struct usb_device *dev, const unsigned char *buf, int length)
+{
+	int res;
+	struct libusb_transfer *xfer = libusb_alloc_transfer(0);
+	libusb_fill_bulk_transfer(xfer, dev->dev, BULK_OUT, (void*)buf, length, tx_callback, dev, 0);
+	xfer->flags = LIBUSB_TRANSFER_SHORT_NOT_OK;
+#ifndef EXPLICIT_ZLP_TRANSACTION
+	if (length % dev->wMaxPacketSize == 0) {
+		xfer->flags |= LIBUSB_TRANSFER_ZERO_PACKET;
+	}
+#endif
+	if((res = libusb_submit_transfer(xfer)) < 0) {
+		usbmuxd_log(LL_ERROR, "Failed to submit TX transfer %p len %d to device %d-%d: %d", buf, length, dev->bus, dev->address, res);
+		libusb_free_transfer(xfer);
+		return res;
+	}
+	collection_add(&dev->tx_xfers, xfer);
+#ifdef EXPLICIT_ZLP_TRANSACTION
+	if (length % dev->wMaxPacketSize == 0) {
+		usbmuxd_log(LL_DEBUG, "Send ZLP");
+		// Send Zero Length Packet
+		xfer = libusb_alloc_transfer(0);
+		void *buffer = malloc(1);
+		libusb_fill_bulk_transfer(xfer, dev->dev, BULK_OUT, buffer, 0, tx_callback, dev, 0);
+		xfer->flags = LIBUSB_TRANSFER_SHORT_NOT_OK;
+		if((res = libusb_submit_transfer(xfer)) < 0) {
+			usbmuxd_log(LL_ERROR, "Failed to submit TX ZLP transfer to device %d-%d: %d", dev->bus, dev->address, res);
+			libusb_free_transfer(xfer);
+			return res;
+		}
+		collection_add(&dev->tx_xfers, xfer);
+	}
+#endif
+	return 0;
+}
+
+static void rx_callback(struct libusb_transfer *xfer)
+{
+	struct usb_device *dev = xfer->user_data;
+	usbmuxd_log(LL_SPEW, "RX callback dev %d-%d len %d status %d", dev->bus, dev->address, xfer->actual_length, xfer->status);
+	if(xfer->status == LIBUSB_TRANSFER_COMPLETED) {
+		device_data_input(dev, xfer->buffer, xfer->actual_length);
+		libusb_submit_transfer(xfer);
+	} else {
+		switch(xfer->status) {
+			case LIBUSB_TRANSFER_COMPLETED: //shut up compiler
+			case LIBUSB_TRANSFER_ERROR:
+				// funny, this happens when we disconnect the device while waiting for a transfer, sometimes
+				usbmuxd_log(LL_INFO, "Device %d-%d RX aborted due to error or disconnect", dev->bus, dev->address);
+				break;
+			case LIBUSB_TRANSFER_TIMED_OUT:
+				usbmuxd_log(LL_ERROR, "RX transfer timed out for device %d-%d", dev->bus, dev->address);
+				break;
+			case LIBUSB_TRANSFER_CANCELLED:
+				usbmuxd_log(LL_DEBUG, "Device %d-%d RX transfer cancelled", dev->bus, dev->address);
+				break;
+			case LIBUSB_TRANSFER_STALL:
+				usbmuxd_log(LL_ERROR, "RX transfer stalled for device %d-%d", dev->bus, dev->address);
+				break;
+			case LIBUSB_TRANSFER_NO_DEVICE:
+				// other times, this happens, and also even when we abort the transfer after device removal
+				usbmuxd_log(LL_INFO, "Device %d-%d RX aborted due to disconnect", dev->bus, dev->address);
+				break;
+			case LIBUSB_TRANSFER_OVERFLOW:
+				usbmuxd_log(LL_ERROR, "RX transfer overflow for device %d-%d", dev->bus, dev->address);
+				break;
+			// and nothing happens (this never gets called) if the device is freed after a disconnect! (bad)
+		}
+		free(xfer->buffer);
+		dev->rx_xfer = NULL;
+		libusb_free_transfer(xfer);
+		// we can't usb_disconnect here due to a deadlock, so instead mark it as dead and reap it after processing events
+		// we'll do device_remove there too
+		dev->alive = 0;
+	}
+}
+
+static int start_rx(struct usb_device *dev)
+{
+	int res;
+	void *buf;
+	dev->rx_xfer = libusb_alloc_transfer(0);
+	buf = malloc(USB_MRU);
+	libusb_fill_bulk_transfer(dev->rx_xfer, dev->dev, BULK_IN, buf, USB_MRU, rx_callback, dev, 0);
+	if((res = libusb_submit_transfer(dev->rx_xfer)) != 0) {
+		usbmuxd_log(LL_ERROR, "Failed to submit RX transfer to device %d-%d: %d", dev->bus, dev->address, res);
+		libusb_free_transfer(dev->rx_xfer);
+		dev->rx_xfer = NULL;
+		return res;
+	}
+	return 0;
+}
+
+static int usb_discover(void)
+{
+	int cnt, i, res;
+	int valid_count = 0;
+	libusb_device **devs;
+
+	cnt = libusb_get_device_list(NULL, &devs);
+	if(cnt < 0) {
+		usbmuxd_log(LL_WARNING, "Could not get device list: %d", cnt);
+		devlist_failures++;
+		// sometimes libusb fails getting the device list if you've just removed something
+		if(devlist_failures > 5) {
+			usbmuxd_log(LL_FATAL, "Too many errors getting device list\n");
+			return cnt;
+		} else {
+			gettimeofday(&next_dev_poll_time, NULL);
+			next_dev_poll_time.tv_usec += DEVICE_POLL_TIME * 1000;
+			next_dev_poll_time.tv_sec += next_dev_poll_time.tv_usec / 1000000;
+			next_dev_poll_time.tv_usec = next_dev_poll_time.tv_usec % 1000000;
+			return 0;
+		}
+	}
+	devlist_failures = 0;
+
+	usbmuxd_log(LL_SPEW, "usb_discover: scanning %d devices", cnt);
+
+	FOREACH(struct usb_device *usbdev, &device_list) {
+		usbdev->alive = 0;
+	} ENDFOREACH
+
+	for(i=0; i<cnt; i++) {
+		// the following are non-blocking operations on the device list
+		libusb_device *dev = devs[i];
+		uint8_t bus = libusb_get_bus_number(dev);
+		uint8_t address = libusb_get_device_address(dev);
+		struct libusb_device_descriptor devdesc;
+		int found = 0;
+		FOREACH(struct usb_device *usbdev, &device_list) {
+			if(usbdev->bus == bus && usbdev->address == address) {
+				valid_count++;
+				usbdev->alive = 1;
+				found = 1;
+				break;
+			}
+		} ENDFOREACH
+		if(found)
+			continue; //device already found
+		if((res = libusb_get_device_descriptor(dev, &devdesc)) != 0) {
+			usbmuxd_log(LL_WARNING, "Could not get device descriptor for device %d-%d: %d", bus, address, res);
+			continue;
+		}
+		if(devdesc.idVendor != VID_APPLE)
+			continue;
+		if( (devdesc.idProduct != PID_IPHONE2G) &&
+			(devdesc.idProduct != PID_ITOUCH1G) &&
+			(devdesc.idProduct != PID_IPHONE3G) &&
+			(devdesc.idProduct != PID_ITOUCH2G) &&
+			(devdesc.idProduct != PID_IPHONE3GS))
+			continue;
+		libusb_device_handle *handle;
+		usbmuxd_log(LL_INFO, "Found new device with v/p %04x:%04x at %d-%d", devdesc.idVendor, devdesc.idProduct, bus, address);
+		// potentially blocking operations follow; they will only run when new devices are detected, which is acceptable
+		if((res = libusb_open(dev, &handle)) != 0) {
+			usbmuxd_log(LL_WARNING, "Could not open device %d-%d: %d", bus, address, res);
+			continue;
+		}
+		int current_config = 0;
+		if((res = libusb_get_configuration(handle, &current_config)) != 0) {
+			usbmuxd_log(LL_WARNING, "Could not get configuration for device %d-%d: %d", bus, address, res);
+			libusb_close(handle);
+			continue;
+		}
+		if (current_config != devdesc.bNumConfigurations) {
+			if((res = libusb_set_configuration(handle, devdesc.bNumConfigurations)) != 0) {
+				usbmuxd_log(LL_WARNING, "Could not set configuration %d for device %d-%d: %d", devdesc.bNumConfigurations, bus, address, res);
+				libusb_close(handle);
+				continue;
+			}
+		}
+		if((res = libusb_claim_interface(handle, USB_INTERFACE)) != 0) {
+			usbmuxd_log(LL_WARNING, "Could not claim interface %d for device %d-%d: %d", USB_INTERFACE, bus, address, res);
+			libusb_close(handle);
+			continue;
+		}
+		struct usb_device *usbdev;
+		usbdev = malloc(sizeof(struct usb_device));
+
+		if((res = libusb_get_string_descriptor_ascii(handle, devdesc.iSerialNumber, (uint8_t *)usbdev->serial, 256)) <= 0) {
+			usbmuxd_log(LL_WARNING, "Could not get serial number for device %d-%d: %d", bus, address, res);
+			libusb_release_interface(handle, USB_INTERFACE);
+			libusb_close(handle);
+			free(usbdev);
+			continue;
+		}
+		usbdev->serial[res] = 0;
+		usbdev->bus = bus;
+		usbdev->address = address;
+		usbdev->vid = devdesc.idVendor;
+		usbdev->pid = devdesc.idProduct;
+		usbdev->dev = handle;
+		usbdev->alive = 1;
+		usbdev->wMaxPacketSize = 0;
+		struct libusb_config_descriptor *cfg;
+		if (libusb_get_active_config_descriptor(dev, &cfg) == 0
+				&& cfg && cfg->bNumInterfaces >= (USB_INTERFACE+1)) {
+			const struct libusb_interface *ifp = &cfg->interface[USB_INTERFACE];
+			if (ifp && ifp->num_altsetting >= 1) {
+				const struct libusb_interface_descriptor *as = &ifp->altsetting[0];
+				int i;
+				for (i = 0; i < as->bNumEndpoints; i++) {
+					const struct libusb_endpoint_descriptor *ep = &as->endpoint[i];
+					if (ep->bEndpointAddress == BULK_OUT) {
+						usbdev->wMaxPacketSize = ep->wMaxPacketSize;
+					}
+				}
+			}
+		}
+		if (usbdev->wMaxPacketSize == 0) {
+			usbmuxd_log(LL_ERROR, "Could not determine wMaxPacketSize for device %d-%d, setting to 64", usbdev->bus, usbdev->address);
+			usbdev->wMaxPacketSize = 64;
+		} else {
+			usbmuxd_log(LL_INFO, "Using wMaxPacketSize=%d for device %d-%d", usbdev->wMaxPacketSize, usbdev->bus, usbdev->address);
+		}
+
+		collection_init(&usbdev->tx_xfers);
+
+		collection_add(&device_list, usbdev);
+
+		if(device_add(usbdev) < 0) {
+			usb_disconnect(usbdev);
+			continue;
+		}
+		if(start_rx(usbdev) < 0) {
+			device_remove(usbdev);
+			usb_disconnect(usbdev);
+			continue;
+		}
+		valid_count++;
+	}
+	FOREACH(struct usb_device *usbdev, &device_list) {
+		if(!usbdev->alive) {
+			device_remove(usbdev);
+			usb_disconnect(usbdev);
+		}
+	} ENDFOREACH
+
+	libusb_free_device_list(devs, 1);
+
+	gettimeofday(&next_dev_poll_time, NULL);
+	next_dev_poll_time.tv_usec += DEVICE_POLL_TIME * 1000;
+	next_dev_poll_time.tv_sec += next_dev_poll_time.tv_usec / 1000000;
+	next_dev_poll_time.tv_usec = next_dev_poll_time.tv_usec % 1000000;
+
+	return valid_count;
+}
+
+const char *usb_get_serial(struct usb_device *dev)
+{
+	if(!dev->dev) {
+		return NULL;
+	}
+	return dev->serial;
+}
+
+uint32_t usb_get_location(struct usb_device *dev)
+{
+	if(!dev->dev) {
+		return 0;
+	}
+	return (dev->bus << 16) | dev->address;
+}
+
+uint16_t usb_get_pid(struct usb_device *dev)
+{
+	if(!dev->dev) {
+		return 0;
+	}
+	return dev->pid;
+}
+
+void usb_get_fds(struct fdlist *list)
+{
+	const struct libusb_pollfd **usbfds;
+	const struct libusb_pollfd **p;
+	usbfds = libusb_get_pollfds(NULL);
+	if(!usbfds) {
+		usbmuxd_log(LL_ERROR, "libusb_get_pollfds failed");
+		return;
+	}
+	p = usbfds;
+	while(*p) {
+		fdlist_add(list, FD_USB, (*p)->fd, (*p)->events);
+		p++;
+	}
+	free(usbfds);
+}
+
+static int dev_poll_remain_ms(void)
+{
+	int msecs;
+	struct timeval tv;
+	gettimeofday(&tv, NULL);
+	msecs = (next_dev_poll_time.tv_sec - tv.tv_sec) * 1000;
+	msecs += (next_dev_poll_time.tv_usec - tv.tv_usec) / 1000;
+	if(msecs < 0)
+		return 0;
+	return msecs;
+}
+
+int usb_get_timeout(void)
+{
+	struct timeval tv;
+	int msec;
+	int res;
+	int pollrem;
+	pollrem = dev_poll_remain_ms();
+	res = libusb_get_next_timeout(NULL, &tv);
+	if(res == 0)
+		return pollrem;
+	if(res < 0) {
+		usbmuxd_log(LL_ERROR, "libusb_get_next_timeout failed: %d", res);
+		return pollrem;
+	}
+	msec = tv.tv_sec * 1000;
+	msec += tv.tv_usec / 1000;
+	if(msec > pollrem)
+		return pollrem;
+	return msec;
+}
+
+int usb_process(void)
+{
+	int res;
+	struct timeval tv;
+	tv.tv_sec = tv.tv_usec = 0;
+	res = libusb_handle_events_timeout(NULL, &tv);
+	if(res < 0) {
+		usbmuxd_log(LL_ERROR, "libusb_handle_events_timeout failed: %d", res);
+		return res;
+	}
+	// reap devices marked dead due to an RX error
+	FOREACH(struct usb_device *usbdev, &device_list) {
+		if(!usbdev->alive) {
+			device_remove(usbdev);
+			usb_disconnect(usbdev);
+		}
+	} ENDFOREACH
+
+	if(dev_poll_remain_ms() <= 0) {
+		res = usb_discover();
+		if(res < 0) {
+			usbmuxd_log(LL_ERROR, "usb_discover failed: %d", res);
+			return res;
+		}
+	}
+	return 0;
+}
+
+int usb_process_timeout(int msec)
+{
+	int res;
+	struct timeval tleft, tcur, tfin;
+	gettimeofday(&tcur, NULL);
+	tfin.tv_sec = tcur.tv_sec + (msec / 1000);
+	tfin.tv_usec = tcur.tv_usec + (msec % 1000) * 1000;
+	tfin.tv_sec += tfin.tv_usec / 1000000;
+	tfin.tv_usec %= 1000000;
+	while((tfin.tv_sec > tcur.tv_sec) || ((tfin.tv_sec == tcur.tv_sec) && (tfin.tv_usec > tcur.tv_usec))) {
+		tleft.tv_sec = tfin.tv_sec - tcur.tv_sec;
+		tleft.tv_usec = tfin.tv_usec - tcur.tv_usec;
+		if(tleft.tv_usec < 0) {
+			tleft.tv_usec += 1000000;
+			tleft.tv_sec -= 1;
+		}
+		res = libusb_handle_events_timeout(NULL, &tleft);
+		if(res < 0) {
+			usbmuxd_log(LL_ERROR, "libusb_handle_events_timeout failed: %d", res);
+			return res;
+		}
+		// reap devices marked dead due to an RX error
+		FOREACH(struct usb_device *usbdev, &device_list) {
+			if(!usbdev->alive) {
+				device_remove(usbdev);
+				usb_disconnect(usbdev);
+			}
+		} ENDFOREACH
+	gettimeofday(&tcur, NULL);
+	}
+	return 0;
+}
+
+int usb_init(void)
+{
+	int res;
+	usbmuxd_log(LL_DEBUG, "usb_init for linux / libusb 1.0");
+
+	devlist_failures = 0;
+	res = libusb_init(NULL);
+	//libusb_set_debug(NULL, 3);
+	if(res != 0) {
+		usbmuxd_log(LL_FATAL, "libusb_init failed: %d", res);
+		return -1;
+	}
+
+	collection_init(&device_list);
+
+	return usb_discover();
+}
+
+void usb_shutdown(void)
+{
+	usbmuxd_log(LL_DEBUG, "usb_shutdown");
+	FOREACH(struct usb_device *usbdev, &device_list) {
+		device_remove(usbdev);
+		usb_disconnect(usbdev);
+	} ENDFOREACH
+	collection_free(&device_list);
+	libusb_exit(NULL);
+}
diff --git a/daemon/usb.h b/daemon/usb.h
new file mode 100644
index 0000000..621ccb2
--- /dev/null
+++ b/daemon/usb.h
@@ -0,0 +1,66 @@
+/*
+	usbmuxd - iPhone/iPod Touch USB multiplex server daemon
+
+Copyright (C) 2009	Hector Martin "marcan" <hector@marcansoft.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 or version 3.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#ifndef __USB_H__
+#define __USB_H__
+
+#include <stdint.h>
+#include "utils.h"
+
+#define BULK_IN 0x85
+#define BULK_OUT 0x04
+
+// libusb fragments packets larger than this (usbfs limitation)
+// on input, this creates race conditions and other issues
+#define USB_MRU 16384
+
+// max transmission packet size
+// libusb fragments these too, but doesn't send ZLPs so we're safe
+// but we need to send a ZLP ourselves at the end (see usb-linux.c)
+// we're using 3 * 16384 to optimize for the fragmentation
+// this results in three URBs per full transfer, 32 USB packets each
+// if there are ZLP issues this should make them show up easily too
+#define USB_MTU (3 * 16384)
+
+#define USB_PACKET_SIZE 512
+
+#define VID_APPLE 0x5ac
+#define PID_IPHONE2G 0x1290
+#define PID_ITOUCH1G 0x1291
+#define PID_IPHONE3G 0x1292
+#define PID_ITOUCH2G 0x1293
+#define PID_IPHONE3GS 0x1294
+
+#define USB_INTERFACE 1
+
+struct usb_device;
+
+int usb_init(void);
+void usb_shutdown(void);
+const char *usb_get_serial(struct usb_device *dev);
+uint32_t usb_get_location(struct usb_device *dev);
+uint16_t usb_get_pid(struct usb_device *dev);
+void usb_get_fds(struct fdlist *list);
+int usb_get_timeout(void);
+int usb_send(struct usb_device *dev, const unsigned char *buf, int length);
+int usb_process(void);
+int usb_process_timeout(int msec);
+
+#endif