USB mostly complete, main loop added, polls for devices

1 files changed, 249 insertions, 2 deletions

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);
+}