USB mostly complete, main loop added, polls for devices

10 files changed, 440 insertions, 36 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 81a6965..acbc779 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,6 +11,6 @@ set(LIBS ${LIBS} ${USB_LIBRARIES})
 #set(CMAKE_VERBOSE_MAKEFILE ON)
 
 add_definitions(-Wall -O2)
-add_executable(usbmuxd main.c usb-linux.c log.c utils.c)
+add_executable(usbmuxd main.c usb-linux.c log.c utils.c device.c)
 target_link_libraries(usbmuxd ${LIBS})
 
diff --git a/device.c b/device.c
new file mode 100644
index 0000000..659f4ae
--- /dev/null
+++ b/device.c
@@ -0,0 +1,56 @@
+/*
+	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 "device.h"
+#include "usb.h"
+#include "log.h"
+
+int device_id;
+/*
+int get_next_device_id(void)
+{
+	int i;
+	while(1) {
+		for(i=0; i<num_devs; i++) {
+			if(device_list[i].dev && device_list[i].id == device_id) {
+				device_id++;
+				break;
+			}
+		}
+		if(i < num_devs)
+			break;
+	}
+	return device_id++;
+}
+*/
+void device_add(struct usb_device *dev)
+{
+	usbmuxd_log(LL_NOTICE, "Connected to new device on location 0x%x with serial number %s", usb_get_location(dev), usb_get_serial(dev));
+}
+
+void device_remove(struct usb_device *dev)
+{
+	usbmuxd_log(LL_NOTICE, "Removed device on location 0x%x with serial number %s", usb_get_location(dev), usb_get_serial(dev));
+}
diff --git a/device.h b/device.h
new file mode 100644
index 0000000..11beaea
--- /dev/null
+++ b/device.h
@@ -0,0 +1,29 @@
+/*
+	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"
+
+void device_add(struct usb_device *dev);
+void device_remove(struct usb_device *dev);
+
+#endif
diff --git a/log.c b/log.c
index d7f57df..29b3506 100644
--- a/log.c
+++ b/log.c
@@ -26,25 +26,33 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
+#include <time.h>
+#include <sys/time.h>
 
 #include "log.h"
 
-int log_level = LOG_SPEW;
+int log_level = LL_SPEW;
 
 void usbmuxd_log(enum loglevel level, const char *fmt, ...)
 {
 	va_list ap;
 	char *fs;
+	struct timeval ts;
+	struct tm *tp;
 	
-	if(level < log_level)
+	gettimeofday(&ts, NULL);
+	tp = localtime(&ts.tv_sec);
+	
+	if(level > log_level)
 		return;
 	
-	fs = malloc(10 + strlen(fmt));
-	sprintf(fs, "[%d] %s\n", level, fmt);
+	fs = malloc(20 + strlen(fmt));
+	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);
 	vfprintf(stderr, fs, ap);
 	va_end(ap);
 	
 	free(fs);
-}
\ No newline at end of file
+}
diff --git a/log.h b/log.h
index fda2e1a..56ecbf4 100644
--- a/log.h
+++ b/log.h
@@ -22,13 +22,13 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 #define __LOG_H__
 
 enum loglevel {
-	LOG_SPEW = 0,
-	LOG_DEBUG,
-	LOG_INFO,
-	LOG_NOTICE,
-	LOG_WARNING,
-	LOG_ERROR,
-	LOG_FATAL,
+	LL_FATAL = 0,
+	LL_ERROR,
+	LL_WARNING,
+	LL_NOTICE,
+	LL_INFO,
+	LL_DEBUG,
+	LL_SPEW,
 };
 
 extern int log_level;
diff --git a/main.c b/main.c
index c2467a2..6773d0e 100644
--- a/main.c
+++ b/main.c
@@ -42,13 +42,13 @@ int create_socket(void) {
 	int listenfd;
 
 	if(unlink(socket_path) == -1 && errno != ENOENT) {
-		usbmuxd_log(LOG_FATAL, "unlink(%s) failed: %s", socket_path, strerror(errno));
+		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(LOG_FATAL, "socket() failed: %s", strerror(errno));
+		usbmuxd_log(LL_FATAL, "socket() failed: %s", strerror(errno));
 		return -1;
 	}
 
@@ -56,37 +56,85 @@ int create_socket(void) {
 	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(LOG_FATAL, "bind() failed: %s", strerror(errno));
+		usbmuxd_log(LL_FATAL, "bind() failed: %s", strerror(errno));
 		return -1;
 	}
 
 	// Start listening
 	if (listen(listenfd, 5) != 0) {
-		usbmuxd_log(LOG_FATAL, "listen() failed: %s", strerror(errno));
+		usbmuxd_log(LL_FATAL, "listen() failed: %s", strerror(errno));
 		return -1;
 	}
 
 	return listenfd;
 }
 
+int main_loop(int listenfd)
+{
+	int to, cnt, i;
+	struct fdlist pollfds;
+	
+	while(1) {
+		usbmuxd_log(LL_SPEW, "main_loop iteration");
+		to = usb_get_timeout();
+		usbmuxd_log(LL_SPEW, "USB timeout is %d ms", to);
+		
+		fdlist_create(&pollfds);
+		usb_get_fds(&pollfds);
+		usbmuxd_log(LL_SPEW, "fd count is %d", pollfds.count);
+		
+		cnt = poll(pollfds.fds, pollfds.count, to);
+		usbmuxd_log(LL_SPEW, "poll() returned %d", cnt);
+		
+		if(cnt == 0) {
+			if(usb_process() < 0) {
+				usbmuxd_log(LL_FATAL, "usb_process() failed");
+				return -1;
+			}
+		} else {
+			for(i=0; i<pollfds.count; i++) {
+				if(pollfds.fds[i].revents) {
+					if(pollfds.owners[i] == FD_USB) {
+						if(usb_process() < 0) {
+							usbmuxd_log(LL_FATAL, "usb_process() failed");
+							return -1;
+						}
+					}
+				}
+			}
+		}
+		fdlist_free(&pollfds);
+	}
+}
+
 int main(int argc, char *argv[])
 {
 	int listenfd;
 	int res;
 
-	usbmuxd_log(LOG_NOTICE, "usbmux v0.1 starting up");
+	usbmuxd_log(LL_NOTICE, "usbmux v0.1 starting up");
 
-	usbmuxd_log(LOG_INFO, "Creating socket");
+	usbmuxd_log(LL_INFO, "Creating socket");
 	listenfd = create_socket();
 	if(listenfd < 0)
 		return 1;
 
-	usbmuxd_log(LOG_INFO, "Initializing USB");
+	usbmuxd_log(LL_INFO, "Initializing USB");
 	if((res = usb_init()) < 0)
 		return 2;
-	usbmuxd_log(LOG_INFO, "%d device%s detected", res, (res==1)?"":"s");
+	usbmuxd_log(LL_INFO, "%d device%s detected", res, (res==1)?"":"s");
 	
-	usbmuxd_log(LOG_NOTICE, "initialization complete");
+	usbmuxd_log(LL_NOTICE, "Initialization complete");
+
+	res = main_loop(listenfd);
+	if(res < 0)
+		usbmuxd_log(LL_FATAL, "main_loop failed");
+
+	usbmuxd_log(LL_NOTICE, "usbmux shutting down");
+	usb_shutdown();
+	usbmuxd_log(LL_NOTICE, "Shutdown complete");
 	
+	if(res < 0)
+		return -res;
 	return 0;
 }
diff --git a/usb-linux.c b/usb-linux.c
index 221ce33..0820ed9 100644
--- a/usb-linux.c
+++ b/usb-linux.c
@@ -24,11 +24,258 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
 
 #include <libusb.h>
 
-int usb_init(void)
+#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;
+	char serial[256];
+	int alive;
+};
+
+int num_devs;
+int device_id;
+struct usb_device *device_list;
+
+struct timeval next_dev_poll_time;
+
+static int alloc_device(void)
 {
+	int i;
+	for(i=0; i<num_devs; i++) {
+		if(!device_list[i].dev)
+			return i;
+	}
+	num_devs++;
+	device_list = realloc(device_list, sizeof(*device_list) * num_devs);
+	memset(&device_list[num_devs-1], 0, sizeof(*device_list));
+	return num_devs - 1;
+}
+
+static void usb_disconnect(struct usb_device *dev)
+{
+	if(!dev->dev) {
+		return;
+	}
+	libusb_release_interface(dev->dev, USB_INTERFACE);
+	libusb_close(dev->dev);
+	dev->dev = NULL;
+}
+
+static int usb_discover(void)
+{
+	int cnt, i, j, res;
+	int valid_count = 0;
+	libusb_device **devs;
+	
+	cnt = libusb_get_device_list(NULL, &devs);
+	if(cnt < 0) {
+		usbmuxd_log(LL_FATAL, "Could not get device list: %d", cnt);
+		return cnt;
+	}
+
+	usbmuxd_log(LL_SPEW, "usb_discover: scanning %d devices", cnt);
+
+	for(j=0; j<num_devs; j++) {
+		device_list[j].alive = 0;
+	}
+	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;
+		for(j=0; j<num_devs; j++) {
+			if(device_list[j].dev && device_list[j].bus == bus && device_list[j].address == address) {
+				valid_count++;
+				device_list[j].alive = 1;
+				break;
+			}
+		}
+		if(j < num_devs)
+			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))
+			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;
+		}
+		if((res = libusb_set_configuration(handle, USB_CONFIGURATION)) != 0) {
+			usbmuxd_log(LL_WARNING, "Could not set configuration %d for device %d-%d: %d", USB_CONFIGURATION, 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;
+		}
+		int idx = alloc_device();
+
+		if((res = libusb_get_string_descriptor_ascii(handle, devdesc.iSerialNumber, (uint8_t *)device_list[idx].serial, 256)) <= 0) {
+			usbmuxd_log(LL_WARNING, "Could not get serial number for device %d-%d: %d", USB_INTERFACE, bus, address, res);
+			libusb_close(handle);
+			continue;
+		}
+		device_list[idx].serial[res] = 0;
+		device_list[idx].bus = bus;
+		device_list[idx].address = address;
+		device_list[idx].dev = handle;
+		device_list[idx].alive = 1;
+		
+		device_add(&device_list[idx]);
+		valid_count++;
+	}
+	for(j=0; j<num_devs; j++) {
+		if(device_list[j].dev && !device_list[j].alive) {
+			device_remove(&device_list[j]);
+			usb_disconnect(&device_list[j]);
+		}
+	}
+	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;
+}
+
+int usb_get_location(struct usb_device *dev)
+{
+	if(!dev->dev) {
+		return 0;
+	}
+	return (dev->bus << 16) | dev->address;
+}
+
+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;
+	}
+	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_init(void)
+{
+	int res;
+	usbmuxd_log(LL_DEBUG, "usb_init for linux / libusb 1.0");
+	
+	res = libusb_init(NULL);
+	if(res != 0) {
+		usbmuxd_log(LL_FATAL, "libusb_init failed: %d", res);
+		return -1;
+	}
+	
+	device_id = 1;
+	num_devs = 1;
+	device_list = malloc(sizeof(*device_list) * num_devs);
+	memset(device_list, 0, sizeof(*device_list) * num_devs);
+	
+	return usb_discover();
+}
+
+void usb_shutdown(void)
+{
+	int i;
+	usbmuxd_log(LL_DEBUG, "usb_shutdown");
+	for(i=0; i<num_devs; i++)
+		usb_disconnect(&device_list[i]);
+	free(device_list);
+	device_list = NULL;
+	libusb_exit(NULL);
+}
diff --git a/usb.h b/usb.h
index cf25c3a..25243d8 100644
--- a/usb.h
+++ b/usb.h
@@ -21,9 +21,27 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 #ifndef __USB_H__
 #define __USB_H__
 
+#include "utils.h"
+
 #define BULK_IN 0x85
 #define BULK_OUT 0x04
 
+#define VID_APPLE 0x5ac
+#define PID_IPHONE2G 0x1290
+#define PID_ITOUCH1G 0x1291
+#define PID_IPHONE3G 0x1292
+
+#define USB_CONFIGURATION 3
+#define USB_INTERFACE 1
+
+struct usb_device;
+
 int usb_init(void);
+void usb_shutdown(void);
+const char *usb_get_serial(struct usb_device *dev);
+int usb_get_location(struct usb_device *dev);
+void usb_get_fds(struct fdlist *list);
+int usb_get_timeout(void);
+int usb_process(void);
 
 #endif
diff --git a/utils.c b/utils.c
index c3d5c50..41c3bcb 100644
--- a/utils.c
+++ b/utils.c
@@ -25,14 +25,14 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 #include <stdlib.h>
 #include "utils.h"
 
-void fdlist_create(fdlist *list)
+void fdlist_create(struct fdlist *list)
 {
 	list->count = 0;
 	list->capacity = 4;
 	list->owners = malloc(sizeof(*list->owners) * list->capacity);
 	list->fds = malloc(sizeof(*list->fds) * list->capacity);
 }
-void fdlist_add(fdlist *list, enum fdowner owner, int fd, short events)
+void fdlist_add(struct fdlist *list, enum fdowner owner, int fd, short events)
 {
 	if(list->count == list->capacity) {
 		list->capacity *= 2;
@@ -46,7 +46,7 @@ void fdlist_add(fdlist *list, enum fdowner owner, int fd, short events)
 	list->count++;
 }
 
-void fdlist_free(fdlist *list)
+void fdlist_free(struct fdlist *list)
 {
 	list->count = 0;
 	list->capacity = 0;
diff --git a/utils.h b/utils.h
index 465487d..9a6d566 100644
--- a/utils.h
+++ b/utils.h
@@ -18,8 +18,8 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 */
 
-#ifndef __LOG_H__
-#define __LOG_H__
+#ifndef __UTILS_H__
+#define __UTILS_H__
 
 #include <poll.h>
 
@@ -29,19 +29,17 @@ enum fdowner {
 	FD_USB
 };
 
-typedef struct {
+struct fdlist {
 	int count;
 	int capacity;
 	enum fdowner *owners;
 	struct pollfd *fds;
-} fdlist;
+};
 
-void fdlist_create(fdlist *list);
-void fdlist_add(fdlist *list, enum fdowner owner, int fd, short events);
-void fdlist_free(fdlist *list);
+void fdlist_create(struct fdlist *list);
+void fdlist_add(struct fdlist *list, enum fdowner owner, int fd, short events);
+void fdlist_free(struct fdlist *list);
 
 #define MIN(X, Y)  ((X) < (Y) ? (X) : (Y))
 
-
-
 #endif