too much stuff and it WORKS

1 files changed, 133 insertions, 64 deletions

diff --git a/usb-linux.c b/usb-linux.c
index 27a7bb1..3a87ba6 100644
--- a/usb-linux.c
+++ b/usb-linux.c
@@ -40,48 +40,50 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 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;
 };
 
-static int num_devs;
-static struct usb_device *device_list;
+static struct collection device_list;
 
 static 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;
 	}
+	
+	// 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) {
-		// kill the rx xfer and try to make sure the rx callback gets called before we free the device
+		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;
-		// TODO: BUG: outstanding TX xfers are not listed but we need to free them
-		libusb_cancel_transfer(dev->rx_xfer);
-		tv.tv_sec = tv.tv_usec = 0;
+		
+		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 device removal failed: %d", res);
+			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)
@@ -117,7 +119,9 @@ static void tx_callback(struct libusb_transfer *xfer)
 		// we'll do device_remove there too
 		dev->alive = 0;
 	}
-	free(xfer->buffer);
+	if(xfer->buffer)
+		free(xfer->buffer);
+	collection_remove(&dev->tx_xfers, xfer);
 	libusb_free_transfer(xfer);
 }
 
@@ -132,6 +136,21 @@ int usb_send(struct usb_device *dev, const unsigned char *buf, int length)
 		libusb_free_transfer(xfer);
 		return res;
 	}
+	collection_add(&dev->tx_xfers, xfer);/*
+	if((length % 512) == 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);
+	}*/
 	return 0;
 }
 
@@ -181,8 +200,8 @@ static int start_rx(struct usb_device *dev)
 	int res;
 	void *buf;
 	dev->rx_xfer = libusb_alloc_transfer(0);
-	buf = malloc(USB_MTU);
-	libusb_fill_bulk_transfer(dev->rx_xfer, dev->dev, BULK_IN, buf, USB_MTU, rx_callback, dev, 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);
@@ -194,7 +213,7 @@ static int start_rx(struct usb_device *dev)
 
 static int usb_discover(void)
 {
-	int cnt, i, j, res;
+	int cnt, i, res;
 	int valid_count = 0;
 	libusb_device **devs;
 	
@@ -206,23 +225,26 @@ static int usb_discover(void)
 
 	usbmuxd_log(LL_SPEW, "usb_discover: scanning %d devices", cnt);
 
-	for(j=0; j<num_devs; j++) {
-		device_list[j].alive = 0;
-	}
+	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;
-		for(j=0; j<num_devs; j++) {
-			if(device_list[j].dev && device_list[j].bus == bus && device_list[j].address == address) {
+		int found = 0;
+		FOREACH(struct usb_device *usbdev, &device_list) {
+			if(usbdev->bus == bus && usbdev->address == address) {
 				valid_count++;
-				device_list[j].alive = 1;
+				usbdev->alive = 1;
+				found = 1;
 				break;
 			}
-		}
-		if(j < num_devs)
+		} 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);
@@ -251,37 +273,45 @@ static int usb_discover(void)
 			libusb_close(handle);
 			continue;
 		}
-		int idx = alloc_device();
+		struct usb_device *usbdev;
+		usbdev = malloc(sizeof(struct usb_device));
 
-		if((res = libusb_get_string_descriptor_ascii(handle, devdesc.iSerialNumber, (uint8_t *)device_list[idx].serial, 256)) <= 0) {
+		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;
 		}
-		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;
+		usbdev->serial[res] = 0;
+		usbdev->bus = bus;
+		usbdev->address = address;
+		usbdev->vid = devdesc.idVendor;
+		usbdev->pid = devdesc.idProduct;
+		usbdev->dev = handle;
+		usbdev->alive = 1;
+		collection_init(&usbdev->tx_xfers);
+
+		collection_add(&device_list, usbdev);
 		
-		if(device_add(&device_list[idx]) < 0) {
-			usb_disconnect(&device_list[j]);
+		if(device_add(usbdev) < 0) {
+			usb_disconnect(usbdev);
 			continue;
 		}
-		if(start_rx(&device_list[idx]) < 0) {
-			device_remove(&device_list[j]);
-			usb_disconnect(&device_list[j]);
+		if(start_rx(usbdev) < 0) {
+			device_remove(usbdev);
+			usb_disconnect(usbdev);
 			continue;
 		}
 		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]);
+	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);
@@ -300,7 +330,7 @@ const char *usb_get_serial(struct usb_device *dev)
 	return dev->serial;
 }
 
-int usb_get_location(struct usb_device *dev)
+uint32_t usb_get_location(struct usb_device *dev)
 {
 	if(!dev->dev) {
 		return 0;
@@ -308,6 +338,14 @@ int usb_get_location(struct usb_device *dev)
 	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;
@@ -360,7 +398,7 @@ int usb_get_timeout(void)
 
 int usb_process(void)
 {
-	int i, res;
+	int res;
 	struct timeval tv;
 	tv.tv_sec = tv.tv_usec = 0;
 	res = libusb_handle_events_timeout(NULL, &tv);
@@ -369,12 +407,12 @@ int usb_process(void)
 		return res;
 	}
 	// reap devices marked dead due to an RX error
-	for(i=0; i<num_devs; i++) {
-		if(device_list[i].dev && !device_list[i].alive) {
-			device_remove(&device_list[i]);
-			usb_disconnect(&device_list[i]);
+	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();
@@ -386,6 +424,39 @@ int usb_process(void)
 	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;
@@ -398,20 +469,18 @@ int usb_init(void)
 		return -1;
 	}
 	
-	num_devs = 1;
-	device_list = malloc(sizeof(*device_list) * num_devs);
-	memset(device_list, 0, sizeof(*device_list) * num_devs);
+	collection_init(&device_list);
 	
 	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;
+	FOREACH(struct usb_device *usbdev, &device_list) {
+		device_remove(usbdev);
+		usb_disconnect(usbdev);
+	} ENDFOREACH
+	collection_free(&device_list);
 	libusb_exit(NULL);
 }