Use autotools build system and add license

Signed-off-by: Nikias Bassen <nikias@gmx.li>

1 files changed, 1351 insertions, 0 deletions

diff --git a/src/main.c b/src/main.c
new file mode 100644
index 0000000..e7292cc
--- /dev/null
+++ b/src/main.c
@@ -0,0 +1,1351 @@
+/*
+ * usbmuxd -- daemon for communication with iPhone/iPod via USB
+ * 
+ * Copyright (c) 2009 Nikias Bassen. All Rights Reserved.
+ * Based upon iTunnel source code, Copyright (c) 2008 Jing Su.
+ *  http://www.cs.toronto.edu/~jingsu/itunnel/
+ *
+ * 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 of the License, or
+ * (at your option) any later version.
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA 
+ */
+#include <stddef.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <getopt.h>
+#include <stdarg.h>
+#include <syslog.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/stat.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <signal.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <usb.h>
+#include <pwd.h>
+
+#include "usbmuxd-proto.h"
+#include "sock_stuff.h"
+
+#include "usbmux.h"
+
+#define DEFAULT_TIMEOUT 4000
+#define DEFAULT_CHILDREN_CAPACITY 10
+#define DEBUG_LEVEL 0
+
+#define LOCKFILE "/var/run/usbmuxd.lock"
+
+#define THREAD (unsigned int)pthread_self()
+
+static int quit_flag = 0;
+static int fsock = -1;
+static int verbose = DEBUG_LEVEL;
+static int foreground = 0;
+static int exit_on_no_devices = 0;
+
+struct device_info {
+	uint32_t device_id;
+	usbmux_device_t phone;
+	int use_count;
+	pthread_t bulk_reader;
+	pthread_mutex_t mutex;
+	/* mutex for mutual exclusion of calling the usbmux_send function
+	 * TODO: I don't know if we need really need this? */
+	pthread_mutex_t writer_mutex;
+};
+
+struct client_data {
+	volatile int dead;
+	int socket;
+	int tag;
+	pthread_t thread;
+	pthread_t handler;
+	pthread_t reader;
+	int reader_quit;
+	int reader_dead;
+	int handler_dead;
+	int connected;
+	usbmux_client_t muxclient;
+	struct device_info *dev;
+};
+
+static struct device_info **devices = NULL;
+static int device_count = 0;
+static pthread_mutex_t usbmux_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t usb_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/**
+ * logs a message to syslog when running as daemon or to stdout/stderr when
+ * running in foreground.
+ * @param prio The logging priority.
+ * @param format The message to be printed.
+ */
+static void logmsg(int prio, const char *format, ...)
+{
+	va_list args;
+	va_start(args, format);
+
+	if (!foreground) {
+		// daemon. log using syslog.
+		vsyslog(prio, format, args);
+	} else {
+		// running in foreground. log to stdout/stderr.
+		char msgbuf[256];
+		FILE *lfp = stdout;
+		switch (prio) {
+		case LOG_EMERG:
+		case LOG_ALERT:
+		case LOG_CRIT:
+		case LOG_ERR:
+		case LOG_WARNING:
+			lfp = stderr;
+			break;
+		default:
+			lfp = stdout;
+		}
+		strcpy(msgbuf, "usbmuxd: ");
+		vsnprintf(msgbuf + 9, 244, format, args);
+		strcat(msgbuf, "\n");
+		fputs(msgbuf, lfp);
+	}
+
+	va_end(args);
+}
+
+#ifdef DEBUG
+/**
+ * for debugging purposes.
+ */
+static void print_buffer(FILE * fp, const char *data, const int length)
+{
+	int i;
+	int j;
+	unsigned char c;
+
+	for (i = 0; i < length; i += 16) {
+		if (verbose >= 4)
+			fprintf(fp, "%04x: ", i);
+		for (j = 0; j < 16; j++) {
+			if (i + j >= length) {
+				if (verbose >= 4)
+					fprintf(fp, "   ");
+				continue;
+			}
+			if (verbose >= 4)
+				fprintf(fp, "%02hhx ", *(data + i + j));
+		}
+		if (verbose >= 4)
+			fprintf(fp, "  | ");
+		for (j = 0; j < 16; j++) {
+			if (i + j >= length)
+				break;
+			c = *(data + i + j);
+			if ((c < 32) || (c > 127)) {
+				if (verbose >= 4)
+					fprintf(fp, ".");
+				continue;
+			}
+			if (verbose >= 4)
+				fprintf(fp, "%c", c);
+		}
+		if (verbose >= 4)
+			fprintf(fp, "\n");
+	}
+	if (verbose >= 4)
+		fprintf(fp, "\n");
+}
+#endif
+
+/**
+ * Read incoming usbmuxd packet. If the packet is larger than
+ * the size specified by len, the data will be truncated.
+ *
+ * @param fd the file descriptor to read from.
+ * @param data pointer to a buffer to store the read data to.
+ * @param len the length of the data to be read. The buffer
+ *        pointed to by data should be at least len bytes in size.
+ *
+ * @return 
+ */
+static int usbmuxd_get_request(int fd, void **data, size_t len)
+{
+	uint32_t pktlen;
+	int recv_len;
+
+	if (peek_buf(fd, &pktlen, sizeof(pktlen)) < (int) sizeof(pktlen)) {
+		return -errno;
+	}
+
+	if (len == 0) {
+		// allocate buffer space
+		*data = malloc(pktlen);
+	} else if (len < pktlen) {
+		// target buffer is to small to hold this packet! fix it!
+		if (verbose >= 2)
+			logmsg(LOG_WARNING,
+				   "%s: WARNING -- packet (%d) is larger than target buffer (%d)! Truncating.",
+				   __func__, pktlen, len);
+		pktlen = len;
+	}
+
+	recv_len = recv_buf(fd, *data, pktlen);
+	if ((recv_len > 0) && ((uint32_t) recv_len < pktlen)) {
+		if (verbose >= 2)
+			logmsg(LOG_WARNING,
+				   "%s: Uh-oh, we got less than the packet's size, %d instead of %d...",
+				   __func__, recv_len, pktlen);
+	}
+#ifdef DEBUG
+	if (*data && (recv_len > 0) && verbose >= 4) {
+		fprintf(stderr, "%s: received:\n", __func__);
+		print_buffer(stderr, *data, recv_len);
+	}
+#endif
+
+	return recv_len;
+}
+
+/**
+ * Send a usbmuxd result packet with given tag and result_code.
+ *
+ * @param fd the file descriptor to write to.
+ * @param tag the tag value that identifies where this message belongs to.
+ * @param result_code the error value (0 = Success, most likely errno values otherwise)
+ *
+ * @return the return value returned by send_buf (normally the number of bytes sent)
+ */
+static int usbmuxd_send_result(int fd, uint32_t tag, uint32_t result_code)
+{
+	struct usbmuxd_result res;
+	int ret;
+
+	res.header.length = sizeof(res);
+	res.header.reserved = 0;
+	res.header.type = USBMUXD_RESULT;
+	res.header.tag = tag;
+	res.result = result_code;
+
+	if (verbose >= 4)
+		logmsg(LOG_NOTICE, "%s: tag=%d result=%d", __func__,
+			   res.header.tag, res.result);
+
+	ret = send_buf(fd, &res, sizeof(res));
+	fsync(fd);					// let's get it sent
+	return ret;
+}
+
+/**
+ * this thread reads from the usb connection and writes the 
+ * data to the connected client.
+ *
+ * @param arg pointer to a client_data structure.
+ *
+ * @return NULL in any case
+ */
+static void *usbmuxd_client_reader_thread(void *arg)
+{
+	struct client_data *cdata;
+
+	char rbuffer[512];
+	uint32_t rbuffersize = 512;
+	uint32_t rlen;
+	int err;
+	char *cursor;
+	ssize_t len;
+	int result;
+
+	if (!arg) {
+		if (verbose >= 2)
+			logmsg(LOG_ERR, "%s: invalid client_data supplied!", __func__);
+		cdata->reader_dead = 1;
+		return NULL;
+	}
+
+	cdata = (struct client_data *) arg;
+
+	cdata->reader_dead = 0;
+
+	if (verbose >= 3)
+		logmsg(LOG_NOTICE, "%s[%d:%d]: started", __func__,
+			   cdata->dev->device_id, cdata->dev->use_count);
+
+	while (!quit_flag && !cdata->reader_quit) {
+		result = check_fd(cdata->socket, FD_WRITE, DEFAULT_TIMEOUT);
+		if (result <= 0) {
+			if (result < 0) {
+				if (verbose >= 2)
+					logmsg(LOG_ERR, "%s: select error: %s", __func__,
+						   strerror(errno));
+			}
+			continue;
+		}
+
+		rlen = 0;
+		err =
+			usbmux_recv_timeout(cdata->muxclient, rbuffer, rbuffersize,
+								&rlen, DEFAULT_TIMEOUT);
+		if (err != 0) {
+			if (verbose >= 2)
+				logmsg(LOG_ERR,
+					   "%s[%d:%d]: encountered USB read error: %d",
+					   __func__, cdata->dev->device_id,
+					   cdata->dev->use_count, err);
+			break;
+		}
+
+		cursor = rbuffer;
+		while (rlen > 0) {
+			len = send_buf(cdata->socket, cursor, rlen);
+			if (len <= 0) {
+				logmsg(LOG_ERR, "%s: Error: send returned %d", __func__,
+					   len);
+				err = 1;
+				break;
+			}
+			// calculate remainder
+			rlen -= len;
+			// advance cursor
+			cursor += len;
+		}
+		if (err != 0) {
+			logmsg(LOG_ERR, "%s: Error when writing to client...",
+				   __func__);
+			break;
+		}
+		fsync(cdata->socket);
+	}
+
+	if (verbose >= 3)
+		logmsg(LOG_NOTICE, "%s[%d:%d]: terminated", __func__,
+			   cdata->dev->device_id, cdata->dev->use_count);
+
+	cdata->reader_dead = 1;
+
+	return NULL;
+}
+
+/**
+ * This function handles the connecting procedure to a previously
+ * set up usbmux client.
+ * Sends a usbmuxd result packet denoting success or failure.
+ * A successful result is mandatory for later communication.
+ *
+ * @param cdata pointer to a previously initialized client_data structure
+ *
+ * @return
+ */
+static int usbmuxd_handleConnectResult(struct client_data *cdata)
+{
+	int result;
+	char buffer[512];
+	char err_type[64];
+	int err_code;
+	ssize_t maxlen = 512;
+	uint32_t rlen;
+	int err;
+
+	if (!cdata) {
+		if (verbose >= 2)
+			logmsg(LOG_ERR, "%s: Invalid client_data provided!", __func__);
+		return -EINVAL;
+	}
+
+	result = check_fd(cdata->socket, FD_WRITE, DEFAULT_TIMEOUT);
+	if (result <= 0) {
+		if (result < 0) {
+			if (verbose >= 2)
+				logmsg(LOG_ERR, "%s: select error: %s", __func__,
+					   strerror(errno));
+			return result;
+		}
+	} else {
+		result = 0;
+		err =
+			usbmux_recv_timeout(cdata->muxclient, buffer, maxlen, &rlen,
+								100);
+		if (err < 0) {
+			if (verbose >= 2)
+				logmsg(LOG_ERR, "%s: encountered USB read error: %d",
+					   __func__, err);
+			usbmuxd_send_result(cdata->socket, cdata->tag, -err);
+			return err;
+		} else {
+			if (rlen > 0) {
+				if ((buffer[0] == 1) && (rlen > 20)
+					&& !memcmp(buffer + 1, "handleConnectResult:", 20)) {
+					// hm... we got an error message!
+					buffer[rlen] = 0;
+					if (verbose >= 1)
+						logmsg(LOG_ERR, "%s: %s\n", __func__, buffer + 22);
+
+					if (sscanf
+						(buffer + 22, "%s - %d\n", err_type, &err_code)
+						== 2) {
+						usbmuxd_send_result(cdata->socket, cdata->tag,
+											err_code);
+						return -err_code;
+					} else {
+						usbmuxd_send_result(cdata->socket, cdata->tag,
+											ENODATA);
+						return -ENODATA;
+					}
+				} else {
+					// send success result
+					usbmuxd_send_result(cdata->socket, cdata->tag, 0);
+					// and the server greeting message
+					send_buf(cdata->socket, buffer, rlen);
+				}
+			} else {
+				// no server greeting? this seems to be ok. send success.
+				usbmuxd_send_result(cdata->socket, cdata->tag, 0);
+			}
+		}
+		//fsync(cdata->socket);
+	}
+	return result;
+}
+
+/**
+ * This thread handles the communication between the connected iPhone/iPod
+ * and the client that created the connection.
+ */
+static void *usbmuxd_client_handler_thread(void *arg)
+{
+	struct client_data *cdata;
+	int result;
+	char *cursor;
+	char buffer[65536];
+	ssize_t len;
+	ssize_t maxlen = sizeof(buffer);
+	uint32_t wlen;
+	int err;
+
+	if (!arg) {
+		if (verbose >= 2)
+			logmsg(LOG_ERR, "%s: invalid client_data provided!", __func__);
+		return NULL;
+	}
+
+	cdata = (struct client_data *) arg;
+
+	if (verbose >= 3)
+		logmsg(LOG_NOTICE, "%s[%d:%d]: started", __func__,
+			   cdata->dev->device_id, cdata->dev->use_count);
+
+	if (usbmuxd_handleConnectResult(cdata)) {
+		if (verbose >= 3)
+			logmsg(LOG_ERR, "handleConnectResult: Error");
+		goto leave;
+	} else {
+		if (verbose >= 3)
+			logmsg(LOG_NOTICE, "handleConnectResult: Success");
+	}
+
+	// starting mux reader thread
+	cdata->reader_quit = 0;
+	cdata->reader_dead = 0;
+	if (pthread_create
+		(&cdata->reader, NULL, usbmuxd_client_reader_thread, cdata) != 0) {
+		if (verbose >= 2)
+			logmsg(LOG_ERR, "%s: could not start client_reader thread",
+				   __func__);
+		cdata->reader = 0;
+	}
+
+	while (!quit_flag && !cdata->reader_dead) {
+		result = check_fd(cdata->socket, FD_READ, DEFAULT_TIMEOUT);
+		if (result <= 0) {
+			if (result < 0) {
+				if (verbose >= 3)
+					logmsg(LOG_ERR, "%s: Error: checkfd: %s", __func__,
+						   strerror(errno));
+			}
+			continue;
+		}
+		// check_fd told us there's data available, so read from client
+		// and push to USB device.
+		len = recv(cdata->socket, buffer, maxlen, 0);
+		if (len == 0) {
+			break;
+		}
+		if (len < 0) {
+			if (verbose >= 2)
+				logmsg(LOG_ERR, "%s[%d:%d]: Error: recv: %s", __func__,
+					   cdata->dev->device_id, cdata->dev->use_count,
+					   strerror(errno));
+			break;
+		}
+
+		cursor = buffer;
+
+		pthread_mutex_lock(&cdata->dev->writer_mutex);
+		do {
+			wlen = 0;
+			err = usbmux_send(cdata->muxclient, cursor, len, &wlen);
+			if (err == -ETIMEDOUT) {
+				// some kind of timeout... just be patient and retry.
+			} else if (err < 0) {
+				if (verbose >= 2)
+					logmsg(LOG_ERR, "%s[%d:%d]: USB write error: %d",
+						   __func__, cdata->dev->device_id,
+						   cdata->dev->use_count, err);
+				len = -1;
+				break;
+			}
+			// calculate remainder.
+			len -= wlen;
+			// advance cursor appropiately.
+			cursor += wlen;
+		}
+		while ((len > 0) && !quit_flag);
+		pthread_mutex_unlock(&cdata->dev->writer_mutex);
+		if (len < 0) {
+			break;
+		}
+	}
+
+  leave:
+	// cleanup
+	if (verbose >= 3)
+		logmsg(LOG_NOTICE, "%s[%d:%d]: terminating", __func__,
+			   cdata->dev->device_id, cdata->dev->use_count);
+	if (cdata->reader != 0) {
+		cdata->reader_quit = 1;
+		pthread_join(cdata->reader, NULL);
+	}
+
+	cdata->handler_dead = 1;
+
+	if (verbose >= 3)
+		logmsg(LOG_NOTICE, "%s[%d:%d]: terminated", __func__,
+			   cdata->dev->device_id, cdata->dev->use_count);
+	return NULL;
+}
+
+/**
+ * Thread performing usb_bulk_read from the connected device.
+ * One thread per device. Lives as long as the device is in use.
+ */
+static void *usbmuxd_bulk_reader_thread(void *arg)
+{
+	struct device_info *cur_dev;
+	int err;
+
+	if (!arg) {
+		if (verbose >= 2)
+			logmsg(LOG_ERR, "%s: Invalid client_data provided", __func__);
+		return NULL;
+	}
+
+	cur_dev = (struct device_info *) arg;
+
+	if (verbose >= 3)
+		logmsg(LOG_NOTICE, "%s: started", __func__);
+
+	while (!quit_flag && cur_dev) {
+
+		pthread_mutex_lock(&cur_dev->mutex);
+		if (cur_dev->use_count <= 0) {
+			pthread_mutex_unlock(&cur_dev->mutex);
+			break;
+		}
+		pthread_mutex_unlock(&cur_dev->mutex);
+
+		if ((err = usbmux_pullbulk(cur_dev->phone)) < 0) {
+			if (verbose >= 1)
+				logmsg(LOG_ERR, "%s: error %d when reading from device",
+					   __func__, err);
+			break;
+		}
+	}
+
+	if (verbose >= 3)
+		logmsg(LOG_NOTICE, "%s: terminated", __func__);
+
+	return NULL;
+}
+
+/**
+ * This thread is started when a new connection is accepted.
+ * It performs the handshake, then waits for the connect packet and
+ * on success it starts the usbmuxd_client_handler thread.
+ */
+static void *usbmuxd_client_init_thread(void *arg)
+{
+	struct client_data *cdata;
+	struct usbmuxd_scan_request *s_req = NULL;
+	struct usbmuxd_device_info_record dev_info_rec;
+	struct usbmuxd_connect_request *c_req = NULL;
+
+	struct usb_bus *bus;
+	struct usb_device *dev;
+
+	int recv_len;
+	int found = 0;
+	int res;
+	int i;
+
+	usbmux_device_t phone = NULL;
+	struct device_info *cur_dev = NULL;
+
+	if (!arg) {
+		if (verbose >= 1)
+			logmsg(LOG_ERR, "%s[%x]: invalid client_data provided!",
+				   __func__, THREAD);
+		return NULL;
+	}
+
+	cdata = (struct client_data *) arg;
+	cdata->dead = 0;
+
+	if (verbose >= 3)
+		logmsg(LOG_NOTICE, "%s[%x]: started (fd=%d)", __func__, THREAD,
+			   cdata->socket);
+
+	if ((recv_len =
+		 usbmuxd_get_request(cdata->socket, (void **) &s_req, 0)) <= 0) {
+		if (verbose >= 2)
+			logmsg(LOG_ERR, "%s[%x]: No scan packet received, error %s",
+				   __func__, THREAD, strerror(errno));
+		goto leave;
+	}
+
+	if ((recv_len == sizeof(struct usbmuxd_scan_request))
+		&& (s_req->header.length == sizeof(struct usbmuxd_scan_request))
+		&& (s_req->header.reserved == 0)
+		&& (s_req->header.type == USBMUXD_SCAN)) {
+		// send success response
+		if (verbose >= 3)
+			logmsg(LOG_NOTICE, "%s[%x]: Got scan packet!", __func__,
+				   THREAD);
+		usbmuxd_send_result(cdata->socket, s_req->header.tag, 0);
+	} else if ((recv_len == sizeof(struct usbmuxd_connect_request))
+			   && (s_req->header.type == USBMUXD_CONNECT)) {
+		c_req = (struct usbmuxd_connect_request *) s_req;
+		s_req = NULL;
+		goto connect;
+	} else {
+		// send error response and exit
+		if (verbose >= 2)
+			logmsg(LOG_ERR, "%s[%x]: Invalid scan packet received.",
+				   __func__, THREAD);
+		// TODO is this required?!
+		usbmuxd_send_result(cdata->socket, s_req->header.tag, EINVAL);
+		goto leave;
+	}
+
+	pthread_mutex_lock(&usb_mutex);
+	// gather data about all iPhones/iPods attached
+
+	if (verbose >= 5)
+		logmsg(LOG_DEBUG, "%s[%x]: usb init", __func__, THREAD);
+	usb_init();
+	if (verbose >= 5)
+		logmsg(LOG_DEBUG, "%s[%x]: usb find busses", __func__, THREAD);
+	usb_find_busses();
+	if (verbose >= 5)
+		logmsg(LOG_DEBUG, "%s[%x]: usb find devices", __func__, THREAD);
+	usb_find_devices();
+
+	if (verbose >= 2)
+		logmsg(LOG_NOTICE, "%s[%x]: Looking for attached devices...",
+			   __func__, THREAD);
+
+	for (bus = usb_get_busses(); bus; bus = bus->next) {
+		for (dev = bus->devices; dev; dev = dev->next) {
+			if (dev->descriptor.idVendor == 0x05ac
+				&& dev->descriptor.idProduct >= 0x1290
+				&& dev->descriptor.idProduct <= 0x1293) {
+				if (verbose >= 1)
+					logmsg(LOG_NOTICE,
+						   "%s[%x]: Found device on bus %d, id %d",
+						   __func__, THREAD, bus->location, dev->devnum);
+				found++;
+
+				// construct packet
+				memset(&dev_info_rec, 0, sizeof(dev_info_rec));
+				dev_info_rec.header.length = sizeof(dev_info_rec);
+				dev_info_rec.header.type = USBMUXD_DEVICE_INFO;
+				dev_info_rec.device.device_id = dev->devnum;
+				dev_info_rec.device.product_id = dev->descriptor.idProduct;
+				if (dev->descriptor.iSerialNumber) {
+					usb_dev_handle *udev;
+					//pthread_mutex_lock(&usbmux_mutex);
+					udev = usb_open(dev);
+					if (udev) {
+						usb_get_string_simple(udev,
+											  dev->descriptor.
+											  iSerialNumber,
+											  dev_info_rec.device.
+											  serial_number,
+											  sizeof(dev_info_rec.device.
+													 serial_number) + 1);
+						usb_close(udev);
+					}
+					//pthread_mutex_unlock(&usbmux_mutex);
+				}
+#ifdef DEBUG
+				if (verbose >= 4)
+					print_buffer(stderr, (char *) &dev_info_rec,
+								 sizeof(dev_info_rec));
+#endif
+
+				// send it
+				if (send_buf
+					(cdata->socket, &dev_info_rec,
+					 sizeof(dev_info_rec)) <= 0) {
+					if (verbose >= 3)
+						logmsg(LOG_ERR,
+							   "%s[%x]: Error: Could not send device info: %s",
+							   __func__, THREAD, strerror(errno));
+					found--;
+				}
+			}
+		}
+	}
+	pthread_mutex_unlock(&usb_mutex);
+
+	if (found <= 0) {
+		if (verbose >= 1)
+			logmsg(LOG_NOTICE,
+				   "%s[%x]: No attached iPhone/iPod devices found.",
+				   __func__, THREAD);
+		goto leave;
+	}
+
+	if (verbose >= 3)
+		logmsg(LOG_NOTICE, "%s[%x]: Waiting for connect request", __func__,
+			   THREAD);
+
+	// now wait for connect request
+	//memset(&c_req, 0, sizeof(c_req));
+	if ((recv_len =
+		 usbmuxd_get_request(cdata->socket, (void **) &c_req, 0)) <= 0) {
+		if (verbose >= 3)
+			logmsg(LOG_NOTICE,
+				   "%s[%x]: Did not receive any connect request.",
+				   __func__, THREAD);
+		goto leave;
+	}
+
+  connect:
+
+	if (c_req->header.type != USBMUXD_CONNECT) {
+		if (verbose >= 2)
+			logmsg(LOG_ERR,
+				   "%s[%x]: Unexpected packet of type %d received.",
+				   __func__, THREAD, c_req->header.type);
+		goto leave;
+	}
+
+	if (verbose >= 3)
+		logmsg(LOG_NOTICE,
+			   "%s[%x]: Setting up connection to usb device #%d on port %d",
+			   __func__, THREAD, c_req->device_id,
+			   ntohs(c_req->tcp_dport));
+
+	// find the device, and open usb connection
+	pthread_mutex_lock(&usbmux_mutex);
+	phone = NULL;
+	cur_dev = NULL;
+	// first check if we already have an open connection
+	if (devices) {
+		for (i = 0; i < device_count; i++) {
+			if (devices[i]) {
+				if (devices[i]->device_id == c_req->device_id) {
+					devices[i]->use_count++;
+					cur_dev = devices[i];
+					phone = cur_dev->phone;
+					break;
+				}
+			}
+		}
+	}
+	if (!phone) {
+		// if not found, make a new connection
+		if (verbose >= 2)
+			logmsg(LOG_NOTICE,
+				   "%s[%x]: creating new usb connection, device_id=%d",
+				   __func__, THREAD, c_req->device_id);
+
+		pthread_mutex_lock(&usb_mutex);
+		if (usbmux_get_specific_device(0, c_req->device_id, &phone) < 0) {
+			pthread_mutex_unlock(&usb_mutex);
+			pthread_mutex_unlock(&usbmux_mutex);
+			if (verbose >= 1)
+				logmsg(LOG_ERR, "%s[%x]: device_id %d could not be opened",
+					   __func__, THREAD, c_req->device_id);
+			usbmuxd_send_result(cdata->socket, c_req->header.tag, ENODEV);
+			goto leave;
+		}
+		pthread_mutex_unlock(&usb_mutex);
+
+		// create device object
+		if (verbose >= 3)
+			logmsg(LOG_DEBUG, "%s[%x]: add to device list", __func__,
+				   THREAD);
+		cur_dev =
+			(struct device_info *) malloc(sizeof(struct device_info));
+		memset(cur_dev, 0, sizeof(struct device_info));
+		cur_dev->use_count = 1;
+		cur_dev->device_id = c_req->device_id;
+		cur_dev->phone = phone;
+		cur_dev->bulk_reader = 0;
+		pthread_mutex_init(&cur_dev->mutex, NULL);
+		pthread_mutex_init(&cur_dev->writer_mutex, NULL);
+
+		if (verbose >= 3)
+			logmsg(LOG_DEBUG, "%s[%x]: device_count = %d", __func__,
+				   THREAD, device_count);
+
+		// add to list of devices
+		devices =
+			(struct device_info **) realloc(devices,
+											sizeof(struct device_info *) *
+											(device_count + 1));
+		if (devices) {
+			devices[device_count] = cur_dev;
+			device_count++;
+		}
+	} else {
+		if (verbose >= 2)
+			logmsg(LOG_NOTICE,
+				   "%s[%x]: reusing usb connection, device_id=%d",
+				   __func__, THREAD, c_req->device_id);
+	}
+	pthread_mutex_unlock(&usbmux_mutex);
+
+	// setup connection to iPhone/iPod
+//    pthread_mutex_lock(&usbmux_mutex);
+	res =
+		usbmux_new_client(cur_dev->phone, 0, ntohs(c_req->tcp_dport),
+						  &(cdata->muxclient));
+//    pthread_mutex_unlock(&usbmux_mutex);
+
+	if (res != 0) {
+		usbmuxd_send_result(cdata->socket, c_req->header.tag, res);
+		if (verbose >= 1)
+			logmsg(LOG_ERR,
+				   "%s[%x]: mux_new_client returned %d, aborting.",
+				   __func__, THREAD, res);
+		goto leave;
+	}
+	// start bulk reader thread (once per device)
+	pthread_mutex_lock(&cur_dev->mutex);
+	if (cur_dev->bulk_reader == 0) {
+		pthread_create(&cur_dev->bulk_reader, NULL,
+					   usbmuxd_bulk_reader_thread, cur_dev);
+	}
+	pthread_mutex_unlock(&cur_dev->mutex);
+
+	// start connection handler thread
+	cdata->handler_dead = 0;
+	cdata->tag = c_req->header.tag;
+	cdata->dev = cur_dev;
+	if (pthread_create
+		(&cdata->handler, NULL, usbmuxd_client_handler_thread, cdata) != 0)
+	{
+		if (verbose >= 1)
+			logmsg(LOG_ERR,
+				   "%s[%x]: could not create usbmuxd_client_handler_thread!",
+				   __func__, THREAD);
+		cdata->handler = 0;
+		goto leave;
+	}
+	// wait for handler thread to finish its work
+	if (cdata->handler != 0) {
+		pthread_join(cdata->handler, NULL);
+	}
+
+	if (verbose >= 2)
+		logmsg(LOG_NOTICE, "%s[%x]: closing connection", __func__, THREAD);
+
+	// time to clean up
+	if (cdata && cdata->muxclient) {	// should be non-NULL
+		usbmux_free_client(cdata->muxclient);
+	}
+
+  leave:
+	if (verbose >= 3)
+		logmsg(LOG_NOTICE, "%s[%x]: terminating", __func__, THREAD);
+
+	if (s_req) {
+		free(s_req);
+	}
+	if (c_req) {
+		free(c_req);
+	}
+	// this has to be freed only if it's not in use anymore as it closes
+	// the USB connection
+	pthread_mutex_lock(&usbmux_mutex);
+	if (cur_dev) {
+		pthread_mutex_lock(&cur_dev->mutex);
+		if (cur_dev->use_count > 1) {
+			if (verbose >= 2)
+				logmsg(LOG_NOTICE,
+					   "%s[%x]: decreasing device use count (from %d to %d)",
+					   __func__, THREAD, cur_dev->use_count,
+					   cur_dev->use_count - 1);
+			cur_dev->use_count--;
+			pthread_mutex_unlock(&cur_dev->mutex);
+		} else {
+			if (verbose >= 2)
+				logmsg(LOG_NOTICE,
+					   "%s[%x]: last client disconnected, cleaning up",
+					   __func__, THREAD);
+			cur_dev->use_count = 0;
+			pthread_mutex_unlock(&cur_dev->mutex);
+			if (cur_dev->bulk_reader != 0) {
+				if (verbose >= 3)
+					logmsg(LOG_NOTICE, "%s[%x]: joining bulk_reader...",
+						   __func__, THREAD);
+				pthread_join(cur_dev->bulk_reader, NULL);
+			}
+			pthread_mutex_lock(&usb_mutex);
+			usbmux_free_device(cur_dev->phone);
+			pthread_mutex_unlock(&usb_mutex);
+			pthread_mutex_destroy(&cur_dev->writer_mutex);
+			pthread_mutex_destroy(&cur_dev->mutex);
+			free(cur_dev);
+			cur_dev = NULL;
+			if (device_count > 1) {
+				struct device_info **newlist;
+				int j;
+
+				newlist =
+					(struct device_info **)
+					malloc(sizeof(struct device_info *)
+						   * device_count - 1);
+				for (i = 0; i < device_count; i++) {
+					if (devices[i] != NULL) {
+						newlist[j++] = devices[i];
+					}
+				}
+				free(devices);
+				devices = newlist;
+				device_count--;
+			} else {
+				free(devices);
+				devices = NULL;
+				device_count = 0;
+			}
+		}
+	}
+	pthread_mutex_unlock(&usbmux_mutex);
+
+	cdata->dead = 1;
+	close(cdata->socket);
+
+	if (verbose >= 3)
+		logmsg(LOG_NOTICE, "%s[%x]: terminated", __func__, THREAD);
+
+	return NULL;
+}
+
+/**
+ * make this program run detached from the current console
+ */
+static int daemonize()
+{
+	pid_t pid;
+	pid_t sid;
+
+	// already a daemon
+	if (getppid() == 1)
+		return 0;
+
+	pid = fork();
+	if (pid < 0) {
+		exit(EXIT_FAILURE);
+	}
+
+	if (pid > 0) {
+		// exit parent process
+		exit(EXIT_SUCCESS);
+	}
+	// At this point we are executing as the child process
+
+	// Change the file mode mask
+	umask(0);
+
+	// Create a new SID for the child process
+	sid = setsid();
+	if (sid < 0) {
+		return -1;
+	}
+	// Change the current working directory.
+	if ((chdir("/")) < 0) {
+		return -2;
+	}
+	// Redirect standard files to /dev/null
+	freopen("/dev/null", "r", stdin);
+	freopen("/dev/null", "w", stdout);
+	freopen("/dev/null", "w", stderr);
+
+	return 0;
+}
+
+/**
+ * signal handler function for cleaning up properly
+ */
+static void clean_exit(int sig)
+{
+	if (sig == SIGINT) {
+		if (verbose >= 1)
+			fprintf(stderr, "CTRL+C pressed\n");
+	}
+	quit_flag = 1;
+}
+
+static void usage()
+{
+	printf("usage: usbmuxd [options]\n");
+	printf("\t-h|--help        print this message.\n");
+	printf("\t-v|--verbose     be verbose\n");
+	printf("\t-f|--foreground  do not daemonize\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'},
+		{"exit-on-no-devices", 0, NULL, 'e'},
+		{NULL, 0, NULL, 0}
+	};
+	int c;
+
+	while (1) {
+		c = getopt_long(argc, argv, "hfve", longopts, (int *) 0);
+		if (c == -1) {
+			break;
+		}
+
+		switch (c) {
+		case 'h':
+			usage();
+			exit(0);
+		case 'f':
+			foreground = 1;
+			break;
+		case 'v':
+			sock_stuff_set_verbose(++verbose);
+			break;
+		case 'e':
+			exit_on_no_devices = 1;
+			break;
+		default:
+			usage();
+			exit(2);
+		}
+	}
+}
+
+/**
+ * checks for attached devices
+ *
+ * @return number of devices found
+ */
+static int devices_attached()
+{
+	struct usb_bus *bus;
+	struct usb_device *dev;
+	int res = 0;
+
+	usb_init();
+	usb_find_busses();
+	usb_find_devices();
+
+	for (bus = usb_get_busses(); bus; bus = bus->next) {
+		for (dev = bus->devices; dev; dev = dev->next) {
+			if (dev->descriptor.idVendor == 0x05ac
+				&& dev->descriptor.idProduct >= 0x1290
+				&& dev->descriptor.idProduct <= 0x1293) {
+				res++;
+			}
+		}
+	}
+
+	return res;
+}
+
+/**
+ * main function. Initializes all stuff and then loops waiting in accept.
+ */
+int main(int argc, char **argv)
+{
+	struct sockaddr_un c_addr;
+	socklen_t len = sizeof(struct sockaddr_un);
+	struct client_data *cdata = NULL;
+	struct client_data **children = NULL;
+	int children_capacity = DEFAULT_CHILDREN_CAPACITY;
+	int i;
+	int result = 0;
+	int cnt = 0;
+	FILE *lfd = NULL;
+	struct flock lock;
+
+	parse_opts(argc, argv);
+
+	argc -= optind;
+	argv += optind;
+
+	if (!foreground) {
+		openlog("usbmuxd", LOG_PID, 0);
+	}
+
+	if (verbose >= 2)
+		logmsg(LOG_NOTICE, "starting");
+
+	// signal(SIGHUP, reload_conf); // none yet
+	signal(SIGINT, clean_exit);
+	signal(SIGQUIT, clean_exit);
+	signal(SIGTERM, clean_exit);
+	signal(SIGPIPE, SIG_IGN);
+
+	// check for other running instance
+	lfd = fopen(LOCKFILE, "r");
+	if (lfd) {
+		lock.l_type = 0;
+		lock.l_whence = SEEK_SET;
+		lock.l_start = 0;
+		lock.l_len = 0;
+		fcntl(fileno(lfd), F_GETLK, &lock);
+		fclose(lfd);
+		if (lock.l_type != F_UNLCK) {
+			logmsg(LOG_NOTICE,
+				   "another instance is already running. exiting.");
+			return -1;
+		}
+	}
+
+	if (exit_on_no_devices) {
+		if (devices_attached() <= 0) {
+			logmsg(LOG_NOTICE, "no devices attached. exiting.");
+			return 0;
+		}
+	}
+
+	fsock = create_unix_socket(USBMUXD_SOCKET_FILE);
+	if (fsock < 0) {
+		logmsg(LOG_ERR, "Could not create socket, exiting");
+		if (!foreground) {
+			closelog();
+		}
+		return -1;
+	}
+
+	chmod(USBMUXD_SOCKET_FILE, 0666);
+
+	if (verbose >= 3)
+		usbmux_set_debug(1);
+
+	if (!foreground) {
+		if (daemonize() < 0) {
+			fprintf(stderr, "usbmuxd: FATAL: Could not daemonize!\n");
+			syslog(LOG_ERR, "FATAL: Could not daemonize!");
+			closelog();
+			exit(EXIT_FAILURE);
+		}
+	}
+	// now open the lockfile and place the lock
+	lfd = fopen(LOCKFILE, "w");
+	if (lfd) {
+		lock.l_type = F_WRLCK;
+		lock.l_whence = SEEK_SET;
+		lock.l_start = 0;
+		lock.l_len = 0;
+		if (fcntl(fileno(lfd), F_SETLK, &lock) == -1) {
+			logmsg(LOG_ERR, "ERROR: lockfile locking failed!");
+		}
+	}
+	// drop elevated privileges
+	if (getuid() == 0 || geteuid() == 0) {
+		struct passwd *pw = getpwnam("nobody");
+		if (pw) {
+			setuid(pw->pw_uid);
+		} else {
+			logmsg(LOG_ERR,
+				   "ERROR: Dropping privileges failed, check if user 'nobody' exists! Will now terminate.");
+			exit(EXIT_FAILURE);
+		}
+
+		// security check
+		if (setuid(0) != -1) {
+			logmsg(LOG_ERR, "ERROR: Failed to drop privileges properly!");
+			exit(EXIT_FAILURE);
+		}
+		if (verbose >= 2)
+			logmsg(LOG_NOTICE, "Successfully dropped privileges");
+	}
+	// Reserve space for 10 clients which should be enough. If not, the
+	// buffer gets enlarged later.
+	children =
+		(struct client_data **) malloc(sizeof(struct client_data *) *
+									   children_capacity);
+	if (!children) {
+		logmsg(LOG_ERR,
+			   "Out of memory when allocating memory for child threads. Terminating.");
+		if (!foreground) {
+			closelog();
+		}
+		exit(EXIT_FAILURE);
+	}
+	memset(children, 0, sizeof(struct client_data *) * children_capacity);
+
+	if (verbose >= 2)
+		logmsg(LOG_NOTICE, "waiting for connection");
+	while (!quit_flag) {
+		// Check the file descriptor before accepting a connection.
+		// If no connection attempt is made, just repeat...
+		result = check_fd(fsock, FD_READ, 1000);
+		if (result <= 0) {
+			if (result == 0) {
+				// cleanup
+				for (i = 0; i < children_capacity; i++) {
+					if (children[i]) {
+						if (children[i]->dead != 0) {
+							pthread_join(children[i]->thread, NULL);
+							if (verbose >= 3)
+								logmsg(LOG_NOTICE,
+									   "reclaimed client thread (fd=%d)",
+									   children[i]->socket);
+							free(children[i]);
+							children[i] = NULL;
+							cnt++;
+						} else {
+							cnt = 0;
+						}
+					} else {
+						cnt++;
+					}
+				}
+
+				if ((children_capacity > DEFAULT_CHILDREN_CAPACITY)
+					&& ((children_capacity - cnt) <=
+						DEFAULT_CHILDREN_CAPACITY)) {
+					children_capacity = DEFAULT_CHILDREN_CAPACITY;
+					children =
+						realloc(children,
+								sizeof(struct client_data *) *
+								children_capacity);
+				}
+				continue;
+			} else {
+				if (verbose >= 3)
+					logmsg(LOG_ERR, "usbmuxd: select error: %s",
+						   strerror(errno));
+				continue;
+			}
+		}
+
+		cdata = (struct client_data *) malloc(sizeof(struct client_data));
+		memset(cdata, 0, sizeof(struct client_data));
+		if (!cdata) {
+			quit_flag = 1;
+			logmsg(LOG_ERR, "Error: Out of memory! Terminating.");
+			break;
+		}
+
+		cdata->socket = accept(fsock, (struct sockaddr *) &c_addr, &len);
+		if (cdata->socket < 0) {
+			free(cdata);
+			if (errno == EINTR) {
+				continue;
+			} else {
+				if (verbose >= 3)
+					logmsg(LOG_ERR, "Error in accept: %s",
+						   strerror(errno));
+				continue;
+			}
+		}
+
+		if (verbose >= 1)
+			logmsg(LOG_NOTICE, "new client connected (fd=%d)",
+				   cdata->socket);
+
+		// create client thread:
+		if (pthread_create
+			(&cdata->thread, NULL, usbmuxd_client_init_thread, cdata) == 0)
+		{
+			for (i = 0; i < children_capacity; i++) {
+				if (children[i] == NULL)
+					break;
+			}
+			if (i == children_capacity) {
+				// enlarge buffer
+				children_capacity++;
+				children =
+					realloc(children,
+							sizeof(struct client_data *) *
+							children_capacity);
+				if (!children) {
+					logmsg(LOG_ERR,
+						   "Out of memory when enlarging child thread buffer");
+				}
+			}
+			children[i] = cdata;
+		} else {
+			logmsg(LOG_ERR, "Failed to create client_init_thread.");
+			close(cdata->socket);
+			free(cdata);
+			cdata = NULL;
+		}
+	}
+
+	if (verbose >= 3)
+		logmsg(LOG_NOTICE, "terminating");
+
+	// preparing for shutdown: wait for child threads to terminate (if any)
+	if (verbose >= 2)
+		logmsg(LOG_NOTICE, "waiting for child threads to terminate...");
+	for (i = 0; i < children_capacity; i++) {
+		if (children[i] != NULL) {
+			pthread_join(children[i]->thread, NULL);
+			free(children[i]);
+		}
+	}
+
+	// delete the children set.
+	free(children);
+	children = NULL;
+
+
+	if (fsock >= 0) {
+		close(fsock);
+	}
+
+	unlink(USBMUXD_SOCKET_FILE);
+
+	// unlock lock file and close it.
+	if (lfd) {
+		lock.l_type = F_UNLCK;
+		fcntl(fileno(lfd), F_SETLK, &lock);
+		fclose(lfd);
+	}
+
+	if (verbose >= 1)
+		logmsg(LOG_NOTICE, "usbmuxd: terminated");
+	if (!foreground) {
+		closelog();
+	}
+
+	return 0;
+}