USBProxyBackendUsbIp.cpp@ 60755

Last change on this file since 60755 was 60755, checked in by vboxsync, 9 years ago
Main/USBProxyBackend: Fixes
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 30.5 KB

Line
1	/* $Id: USBProxyBackendUsbIp.cpp 60755 2016-04-29 10:00:11Z vboxsync $ */
2	/** @file
3	* VirtualBox USB Proxy Backend, USB/IP.
4	*/
5
6	/*
7	* Copyright (C) 2015 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.215389.xyz. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#include "USBProxyService.h"
23	#include "USBGetDevices.h"
24	#include "Logging.h"
25
26	#include <VBox/usb.h>
27	#include <VBox/usblib.h>
28	#include <VBox/err.h>
29
30	#include <iprt/string.h>
31	#include <iprt/alloc.h>
32	#include <iprt/assert.h>
33	#include <iprt/ctype.h>
34	#include <iprt/tcp.h>
35	#include <iprt/env.h>
36	#include <iprt/err.h>
37	#include <iprt/mem.h>
38	#include <iprt/pipe.h>
39	#include <iprt/asm.h>
40	#include <iprt/cdefs.h>
41
42	/** The USB/IP default port to connect to. */
43	#define USBIP_PORT_DEFAULT 3240
44	/** The USB version number used for the protocol. */
45	#define USBIP_VERSION UINT16_C(0x0111)
46	/** Request indicator in the command code. */
47	#define USBIP_INDICATOR_REQ RT_BIT(15)
48
49	/** Command/Reply code for OP_REQ/RET_DEVLIST. */
50	#define USBIP_REQ_RET_DEVLIST UINT16_C(5)
51
52	/** @todo: Duplicate code in USBProxyDevice-usbip.cpp */
53	/**
54	* Exported device entry in the OP_RET_DEVLIST reply.
55	*/
56	#pragma pack(1)
57	typedef struct UsbIpExportedDevice
58	{
59	/** Path of the device, zero terminated string. */
60	char szPath[256];
61	/** Bus ID of the exported device, zero terminated string. */
62	char szBusId[32];
63	/** Bus number. */
64	uint32_t u32BusNum;
65	/** Device number. */
66	uint32_t u32DevNum;
67	/** Speed indicator of the device. */
68	uint32_t u32Speed;
69	/** Vendor ID of the device. */
70	uint16_t u16VendorId;
71	/** Product ID of the device. */
72	uint16_t u16ProductId;
73	/** Device release number. */
74	uint16_t u16BcdDevice;
75	/** Device class. */
76	uint8_t bDeviceClass;
77	/** Device Subclass. */
78	uint8_t bDeviceSubClass;
79	/** Device protocol. */
80	uint8_t bDeviceProtocol;
81	/** Configuration value. */
82	uint8_t bConfigurationValue;
83	/** Current configuration value of the device. */
84	uint8_t bNumConfigurations;
85	/** Number of interfaces for the device. */
86	uint8_t bNumInterfaces;
87	} UsbIpExportedDevice;
88	/** Pointer to a exported device entry. */
89	typedef UsbIpExportedDevice *PUsbIpExportedDevice;
90	#pragma pack()
91	AssertCompileSize(UsbIpExportedDevice, 312);
92
93	/**
94	* Interface descriptor entry for an exported device.
95	*/
96	#pragma pack(1)
97	typedef struct UsbIpDeviceInterface
98	{
99	/** Intefrace class. */
100	uint8_t bInterfaceClass;
101	/** Interface sub class. */
102	uint8_t bInterfaceSubClass;
103	/** Interface protocol identifier. */
104	uint8_t bInterfaceProtocol;
105	/** Padding byte for alignment. */
106	uint8_t bPadding;
107	} UsbIpDeviceInterface;
108	/** Pointer to an interface descriptor entry. */
109	typedef UsbIpDeviceInterface *PUsbIpDeviceInterface;
110	#pragma pack()
111
112	/**
113	* USB/IP device list request.
114	*/
115	#pragma pack(1)
116	typedef struct UsbIpReqDevList
117	{
118	/** Protocol version number. */
119	uint16_t u16Version;
120	/** Command code. */
121	uint16_t u16Cmd;
122	/** Status field, unused. */
123	int32_t u32Status;
124	} UsbIpReqDevList;
125	/** Pointer to a device list request. */
126	typedef UsbIpReqDevList *PUsbIpReqDevList;
127	#pragma pack()
128
129	/**
130	* USB/IP Import reply.
131	*
132	* This is only the header, for successful
133	* requests the device details are sent to as
134	* defined in UsbIpExportedDevice.
135	*/
136	#pragma pack(1)
137	typedef struct UsbIpRetDevList
138	{
139	/** Protocol version number. */
140	uint16_t u16Version;
141	/** Command code. */
142	uint16_t u16Cmd;
143	/** Status field, unused. */
144	int32_t u32Status;
145	/** Number of exported devices. */
146	uint32_t u32DevicesExported;
147	} UsbIpRetDevList;
148	/** Pointer to a import reply. */
149	typedef UsbIpRetDevList *PUsbIpRetDevList;
150	#pragma pack()
151
152	/** Pollset id of the socket. */
153	#define USBIP_POLL_ID_SOCKET 0
154	/** Pollset id of the pipe. */
155	#define USBIP_POLL_ID_PIPE 1
156
157	/** @name USB/IP error codes.
158	* @{ */
159	/** Success indicator. */
160	#define USBIP_STATUS_SUCCESS INT32_C(0)
161	/** @} */
162
163	/** @name USB/IP device speeds.
164	* @{ */
165	/** Unknown speed. */
166	#define USBIP_SPEED_UNKNOWN 0
167	/** Low (1.0) speed. */
168	#define USBIP_SPEED_LOW 1
169	/** Full (1.1) speed. */
170	#define USBIP_SPEED_FULL 2
171	/** High (2.0) speed. */
172	#define USBIP_SPEED_HIGH 3
173	/** Variable (CWUSB) speed. */
174	#define USBIP_SPEED_WIRELESS 4
175	/** Super (3.0) speed. */
176	#define USBIP_SPEED_SUPER 5
177	/** @} */
178
179	/**
180	* Private USB/IP proxy backend data.
181	*/
182	struct USBProxyBackendUsbIp::Data
183	{
184	Data()
185	: hSocket(NIL_RTSOCKET),
186	hWakeupPipeR(NIL_RTPIPE),
187	hWakeupPipeW(NIL_RTPIPE),
188	hPollSet(NIL_RTPOLLSET),
189	uPort(USBIP_PORT_DEFAULT),
190	pszHost(NULL),
191	hMtxDevices(NIL_RTSEMFASTMUTEX),
192	cUsbDevicesCur(0),
193	pUsbDevicesCur(NULL),
194	enmRecvState(kUsbIpRecvState_Invalid),
195	cbResidualRecv(0),
196	pbRecvBuf(NULL),
197	cDevicesLeft(0),
198	pHead(NULL),
199	ppNext(&pHead)
200	{ }
201
202	/** Socket handle to the server. */
203	RTSOCKET hSocket;
204	/** Pipe used to interrupt wait(), the read end. */
205	RTPIPE hWakeupPipeR;
206	/** Pipe used to interrupt wait(), the write end. */
207	RTPIPE hWakeupPipeW;
208	/** Pollset for the socket and wakeup pipe. */
209	RTPOLLSET hPollSet;
210	/** Port of the USB/IP host to connect to. */
211	uint32_t uPort;
212	/** USB/IP host address. */
213	char *pszHost;
214	/** Mutex protecting the device list against concurrent access. */
215	RTSEMFASTMUTEX hMtxDevices;
216	/** Number of devices in the list. */
217	uint32_t cUsbDevicesCur;
218	/** The current list of devices to compare with. */
219	PUSBDEVICE pUsbDevicesCur;
220	/** Current receive state. */
221	USBIPRECVSTATE enmRecvState;
222	/** Scratch space for holding the data until it was completely received.
223	* Which one to access is based on the current receive state. */
224	union
225	{
226	UsbIpRetDevList RetDevList;
227	UsbIpExportedDevice ExportedDevice;
228	UsbIpDeviceInterface DeviceInterface;
229	/** Byte view. */
230	uint8_t abRecv[1];
231	} Scratch;
232	/** Residual number of bytes to receive before we can work with the data. */
233	size_t cbResidualRecv;
234	/** Current pointer into the scratch buffer. */
235	uint8_t *pbRecvBuf;
236	/** Number of devices left to receive for the current request. */
237	uint32_t cDevicesLeft;
238	/** Number of interfaces to skip during receive. */
239	uint32_t cInterfacesLeft;
240	/** The current head pointer for the new device list. */
241	PUSBDEVICE pHead;
242	/** The next pointer to add a device to. */
243	PUSBDEVICE *ppNext;
244	/** Current amount of devices in the list. */
245	uint32_t cDevicesCur;
246	};
247
248	/**
249	* Convert the given exported device structure from host to network byte order.
250	*
251	* @returns nothing.
252	* @param pDevice The device structure to convert.
253	*/
254	DECLINLINE(void) usbProxyBackendUsbIpExportedDeviceN2H(PUsbIpExportedDevice pDevice)
255	{
256	pDevice->u32BusNum = RT_N2H_U32(pDevice->u32BusNum);
257	pDevice->u32DevNum = RT_N2H_U32(pDevice->u32DevNum);
258	pDevice->u32Speed = RT_N2H_U16(pDevice->u32Speed);
259	pDevice->u16VendorId = RT_N2H_U16(pDevice->u16VendorId);
260	pDevice->u16ProductId = RT_N2H_U16(pDevice->u16ProductId);
261	pDevice->u16BcdDevice = RT_N2H_U16(pDevice->u16BcdDevice);
262	}
263
264	/**
265	* Initialize data members.
266	*/
267	USBProxyBackendUsbIp::USBProxyBackendUsbIp()
268	: USBProxyBackend()
269	{
270	}
271
272	USBProxyBackendUsbIp::~USBProxyBackendUsbIp()
273	{
274
275	}
276
277	/**
278	* Initializes the object (called right after construction).
279	*
280	* @returns S_OK on success and non-fatal failures, some COM error otherwise.
281	*/
282	int USBProxyBackendUsbIp::init(USBProxyService *aUsbProxyService, const com::Utf8Str &strId, const com::Utf8Str &strAddress)
283	{
284	int rc = VINF_SUCCESS;
285
286	USBProxyBackend::init(aUsbProxyService, strId, strAddress);
287
288	unconst(m_strBackend) = Utf8Str("USBIP");
289
290	m = new Data;
291
292	/* Split address into hostname and port. */
293	RTCList<RTCString> lstAddress = strAddress.split(":");
294	if (lstAddress.size() < 1)
295	return VERR_INVALID_PARAMETER;
296	m->pszHost = RTStrDup(lstAddress[0].c_str());
297	if (!m->pszHost)
298	return VERR_NO_STR_MEMORY;
299	if (lstAddress.size() == 2)
300	{
301	m->uPort = lstAddress[1].toUInt32();
302	if (!m->uPort)
303	return VERR_INVALID_PARAMETER;
304	}
305
306	/* Setup wakeup pipe and poll set first. */
307	rc = RTSemFastMutexCreate(&m->hMtxDevices);
308	if (RT_SUCCESS(rc))
309	{
310	rc = RTPipeCreate(&m->hWakeupPipeR, &m->hWakeupPipeW, 0);
311	if (RT_SUCCESS(rc))
312	{
313	rc = RTPollSetCreate(&m->hPollSet);
314	if (RT_SUCCESS(rc))
315	{
316	rc = RTPollSetAddPipe(m->hPollSet, m->hWakeupPipeR,
317	RTPOLL_EVT_READ, USBIP_POLL_ID_PIPE);
318	if (RT_SUCCESS(rc))
319	{
320	/* Connect to the USB/IP host. */
321	rc = reconnect();
322	if (RT_SUCCESS(rc))
323	rc = start(); /* Start service thread. */
324	}
325
326	if (RT_FAILURE(rc))
327	{
328	RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_PIPE);
329	int rc2 = RTPollSetDestroy(m->hPollSet);
330	AssertRC(rc2);
331	m->hPollSet = NIL_RTPOLLSET;
332	}
333	}
334
335	if (RT_FAILURE(rc))
336	{
337	int rc2 = RTPipeClose(m->hWakeupPipeR);
338	AssertRC(rc2);
339	rc2 = RTPipeClose(m->hWakeupPipeW);
340	AssertRC(rc2);
341	m->hWakeupPipeR = m->hWakeupPipeW = NIL_RTPIPE;
342	}
343	}
344	if (RT_FAILURE(rc))
345	{
346	RTSemFastMutexDestroy(m->hMtxDevices);
347	m->hMtxDevices = NIL_RTSEMFASTMUTEX;
348	}
349	}
350
351	return rc;
352	}
353
354	/**
355	* Stop all service threads and free the device chain.
356	*/
357	void USBProxyBackendUsbIp::uninit()
358	{
359	LogFlowThisFunc(("\n"));
360
361	/*
362	* Stop the service.
363	*/
364	if (isActive())
365	stop();
366
367	/*
368	* Free resources.
369	*/
370	if (m->hPollSet != NIL_RTPOLLSET)
371	{
372	disconnect();
373
374	int rc = RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_PIPE);
375	AssertRC(rc);
376	rc = RTPollSetDestroy(m->hPollSet);
377	AssertRC(rc);
378	rc = RTPipeClose(m->hWakeupPipeR);
379	AssertRC(rc);
380	rc = RTPipeClose(m->hWakeupPipeW);
381	AssertRC(rc);
382
383	m->hPollSet = NIL_RTPOLLSET;
384	m->hWakeupPipeR = NIL_RTPIPE;
385	m->hWakeupPipeW = NIL_RTPIPE;
386	}
387
388	if (m->pszHost)
389	RTStrFree(m->pszHost);
390	if (m->hMtxDevices != NIL_RTSEMFASTMUTEX)
391	{
392	RTSemFastMutexDestroy(m->hMtxDevices);
393	m->hMtxDevices = NIL_RTSEMFASTMUTEX;
394	}
395
396	delete m;
397	USBProxyBackend::uninit();
398	}
399
400
401	int USBProxyBackendUsbIp::captureDevice(HostUSBDevice *aDevice)
402	{
403	AssertReturn(aDevice, VERR_GENERAL_FAILURE);
404	AssertReturn(!aDevice->isWriteLockOnCurrentThread(), VERR_GENERAL_FAILURE);
405
406	AutoReadLock devLock(aDevice COMMA_LOCKVAL_SRC_POS);
407	LogFlowThisFunc(("aDevice=%s\n", aDevice->i_getName().c_str()));
408
409	/*
410	* We don't need to do anything when the device is held... fake it.
411	*/
412	Assert(aDevice->i_getUnistate() == kHostUSBDeviceState_Capturing);
413	devLock.release();
414
415	return VINF_SUCCESS;
416	}
417
418
419	int USBProxyBackendUsbIp::releaseDevice(HostUSBDevice *aDevice)
420	{
421	AssertReturn(aDevice, VERR_GENERAL_FAILURE);
422	AssertReturn(!aDevice->isWriteLockOnCurrentThread(), VERR_GENERAL_FAILURE);
423
424	AutoReadLock devLock(aDevice COMMA_LOCKVAL_SRC_POS);
425	LogFlowThisFunc(("aDevice=%s\n", aDevice->i_getName().c_str()));
426
427	/*
428	* We're not really holding it atm., just fake it.
429	*/
430	Assert(aDevice->i_getUnistate() == kHostUSBDeviceState_ReleasingToHost);
431	devLock.release();
432
433	return VINF_SUCCESS;
434	}
435
436
437	bool USBProxyBackendUsbIp::isFakeUpdateRequired()
438	{
439	return true;
440	}
441
442
443	int USBProxyBackendUsbIp::wait(RTMSINTERVAL aMillies)
444	{
445	int rc = VINF_SUCCESS;
446	bool fDeviceListChangedOrWokenUp = false;
447
448	/* Try to reconnect once when we enter if we lost the connection earlier. */
449	if (m->hSocket == NIL_RTSOCKET)
450	rc = reconnect();
451
452	/* Query a new device list upon entering. */
453	if ( RT_SUCCESS(rc)
454	&& m->enmRecvState == kUsbIpRecvState_None)
455	{
456	rc = startListExportedDevicesReq();
457	if (RT_FAILURE(rc))
458	disconnect();
459	}
460
461	/*
462	* Because the USB/IP protocol doesn't specify a way to get notified about
463	* new or removed exported devices we have to poll the host periodically for
464	* a new device list and compare it with the previous one notifying the proxy
465	* service about changes.
466	*/
467	while ( !fDeviceListChangedOrWokenUp
468	&& (aMillies == RT_INDEFINITE_WAIT \|\| aMillies > 0)
469	&& RT_SUCCESS(rc))
470	{
471	RTMSINTERVAL msWait = aMillies;
472	uint64_t msPollStart = RTTimeMilliTS();
473	uint32_t uIdReady = 0;
474	uint32_t fEventsRecv = 0;
475
476	/* Limit the waiting time to 1sec so we can either reconnect or get a new device list. */
477	if (m->hSocket == NIL_RTSOCKET \|\| m->enmRecvState == kUsbIpRecvState_None)
478	msWait = RT_MIN(1000, aMillies);
479
480	rc = RTPoll(m->hPollSet, msWait, &fEventsRecv, &uIdReady);
481	if (RT_SUCCESS(rc))
482	{
483	if (uIdReady == USBIP_POLL_ID_PIPE)
484	{
485	/* Drain the wakeup pipe. */
486	char bRead = 0;
487	size_t cbRead = 0;
488
489	rc = RTPipeRead(m->hWakeupPipeR, &bRead, 1, &cbRead);
490	Assert(RT_SUCCESS(rc) && cbRead == 1);
491	fDeviceListChangedOrWokenUp = true;
492	}
493	else if (uIdReady == USBIP_POLL_ID_SOCKET)
494	{
495	if (fEventsRecv & RTPOLL_EVT_READ)
496	rc = receiveData();
497	if ( RT_SUCCESS(rc)
498	&& (fEventsRecv & RTPOLL_EVT_ERROR))
499	rc = VERR_NET_SHUTDOWN;
500
501	if (RT_SUCCESS(rc))
502	{
503	/*
504	* If we are in the none state again we received the previous request
505	* and have a new device list to compare the old against.
506	*/
507	if (m->enmRecvState == kUsbIpRecvState_None)
508	{
509	if (hasDevListChanged(m->pHead))
510	fDeviceListChangedOrWokenUp = true;
511
512	/* Update to the new list in any case now that we have it anyway. */
513	RTSemFastMutexRequest(m->hMtxDevices);
514	freeDeviceList(m->pUsbDevicesCur);
515	m->cUsbDevicesCur = m->cDevicesCur;
516	m->pUsbDevicesCur = m->pHead;
517	RTSemFastMutexRelease(m->hMtxDevices);
518
519	m->pHead = NULL;
520	resetRecvState();
521	}
522	}
523	else if (rc == VERR_NET_SHUTDOWN \|\| rc == VERR_BROKEN_PIPE \|\| rc == VERR_NET_CONNECTION_RESET_BY_PEER)
524	{
525	Log(("USB/IP: Lost connection to host \"%s\", trying to reconnect...\n", m->pszHost));
526	disconnect();
527	rc = VINF_SUCCESS;
528	}
529	}
530	else
531	{
532	AssertMsgFailed(("Invalid poll ID returned\n"));
533	rc = VERR_INVALID_STATE;
534	}
535	aMillies -= (RTTimeMilliTS() - msPollStart);
536	}
537	else if (rc == VERR_TIMEOUT)
538	{
539	aMillies -= msWait;
540	if (aMillies)
541	{
542	/* Try to reconnect and start a new request if we lost the connection before. */
543	if (m->hSocket == NIL_RTSOCKET)
544	rc = reconnect();
545
546	if (RT_SUCCESS(rc))
547	rc = startListExportedDevicesReq();
548	}
549	}
550	}
551
552	LogFlowFunc(("return rc=%Rrc\n", rc));
553	return rc;
554	}
555
556
557	int USBProxyBackendUsbIp::interruptWait(void)
558	{
559	AssertReturn(!isWriteLockOnCurrentThread(), VERR_GENERAL_FAILURE);
560
561	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
562
563	int rc = RTPipeWriteBlocking(m->hWakeupPipeW, "", 1, NULL);
564	if (RT_SUCCESS(rc))
565	RTPipeFlush(m->hWakeupPipeW);
566	LogFlowFunc(("returning %Rrc\n", rc));
567	return rc;
568	}
569
570
571	PUSBDEVICE USBProxyBackendUsbIp::getDevices(void)
572	{
573	PUSBDEVICE pFirst = NULL;
574	PUSBDEVICE *ppNext = &pFirst;
575
576	/* Create a deep copy of the device list. */
577	RTSemFastMutexRequest(m->hMtxDevices);
578	PUSBDEVICE pCur = m->pUsbDevicesCur;
579	while (pCur)
580	{
581	PUSBDEVICE pNew = (PUSBDEVICE)RTMemAllocZ(sizeof(USBDEVICE));
582	if (pNew)
583	{
584	pNew->pszManufacturer = RTStrDup(pCur->pszManufacturer);
585	pNew->pszProduct = RTStrDup(pCur->pszProduct);
586	if (pCur->pszSerialNumber)
587	pNew->pszSerialNumber = RTStrDup(pCur->pszSerialNumber);
588	pNew->pszBackend = RTStrDup(pCur->pszBackend);
589	pNew->pszAddress = RTStrDup(pCur->pszAddress);
590
591	pNew->idVendor = pCur->idVendor;
592	pNew->idProduct = pCur->idProduct;
593	pNew->bcdDevice = pCur->bcdDevice;
594	pNew->bcdUSB = pCur->bcdUSB;
595	pNew->bDeviceClass = pCur->bDeviceClass;
596	pNew->bDeviceSubClass = pCur->bDeviceSubClass;
597	pNew->bDeviceProtocol = pCur->bDeviceProtocol;
598	pNew->bNumConfigurations = pCur->bNumConfigurations;
599	pNew->enmState = pCur->enmState;
600	pNew->u64SerialHash = pCur->u64SerialHash;
601	pNew->bBus = pCur->bBus;
602	pNew->bPort = pCur->bPort;
603	pNew->enmSpeed = pCur->enmSpeed;
604
605	/* link it */
606	pNew->pNext = NULL;
607	pNew->pPrev = *ppNext;
608	*ppNext = pNew;
609	ppNext = &pNew->pNext;
610	}
611
612	pCur = pCur->pNext;
613	}
614	RTSemFastMutexRelease(m->hMtxDevices);
615
616	return pFirst;
617	}
618
619	/**
620	* Frees a given device list.
621	*
622	* @returns nothing.
623	* @param pHead The head of the device list to free.
624	*/
625	void USBProxyBackendUsbIp::freeDeviceList(PUSBDEVICE pHead)
626	{
627	PUSBDEVICE pNext = pHead;
628	while (pNext)
629	{
630	PUSBDEVICE pFree = pNext;
631	pNext = pNext->pNext;
632	freeDevice(pFree);
633	}
634	}
635
636	/**
637	* Resets the receive state to the idle state.
638	*
639	* @returns nothing.
640	*/
641	void USBProxyBackendUsbIp::resetRecvState()
642	{
643	freeDeviceList(m->pHead);
644	m->pHead = NULL;
645	m->ppNext = &m->pHead;
646	m->cDevicesCur = 0;
647	m->enmRecvState = kUsbIpRecvState_None;
648	m->cbResidualRecv = 0;
649	m->pbRecvBuf = &m->Scratch.abRecv[0];
650	m->cDevicesLeft = 0;
651	}
652
653	/**
654	* Disconnects from the host and resets the receive state.
655	*
656	* @returns nothing.
657	*/
658	void USBProxyBackendUsbIp::disconnect()
659	{
660	if (m->hSocket != NIL_RTSOCKET)
661	{
662	int rc = RTPollSetRemove(m->hPollSet, USBIP_POLL_ID_SOCKET);
663	Assert(RT_SUCCESS(rc) \|\| rc == VERR_POLL_HANDLE_ID_NOT_FOUND);
664
665	RTTcpClientCloseEx(m->hSocket, false /fGracefulShutdown/);
666	m->hSocket = NIL_RTSOCKET;
667	}
668
669	resetRecvState();
670	}
671
672	/**
673	* Tries to reconnect to the USB/IP host.
674	*
675	* @returns VBox status code.
676	*/
677	int USBProxyBackendUsbIp::reconnect()
678	{
679	/* Make sure we are disconnected. */
680	disconnect();
681
682	/* Connect to the USB/IP host. */
683	int rc = RTTcpClientConnect(m->pszHost, m->uPort, &m->hSocket);
684	if (RT_SUCCESS(rc))
685	{
686	rc = RTTcpSetSendCoalescing(m->hSocket, false);
687	if (RT_FAILURE(rc))
688	LogRelMax(5, ("USB/IP: Disabling send coalescing failed (rc=%Rrc), continuing nevertheless but expect increased latency\n", rc));
689
690	rc = RTPollSetAddSocket(m->hPollSet, m->hSocket, RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR,
691	USBIP_POLL_ID_SOCKET);
692	if (RT_FAILURE(rc))
693	{
694	RTTcpClientCloseEx(m->hSocket, false /fGracefulShutdown/);
695	m->hSocket = NIL_RTSOCKET;
696	}
697	else
698	LogFlowFunc(("Connected to host \"%s\"\n", m->pszHost));
699	}
700
701	return rc;
702	}
703
704	/**
705	* Initiates a new List Exported Devices request.
706	*
707	* @returns VBox status code.
708	*/
709	int USBProxyBackendUsbIp::startListExportedDevicesReq()
710	{
711	int rc = VINF_SUCCESS;
712
713	/*
714	* Reset the current state and reconnect in case we were called in the middle
715	* of another transfer (which should not happen).
716	*/
717	Assert(m->enmRecvState == kUsbIpRecvState_None);
718	if (m->enmRecvState != kUsbIpRecvState_None)
719	rc = reconnect();
720
721	if (RT_SUCCESS(rc))
722	{
723	/* Send of the request. */
724	UsbIpReqDevList ReqDevList;
725	ReqDevList.u16Version = RT_H2N_U16(USBIP_VERSION);
726	ReqDevList.u16Cmd = RT_H2N_U16(USBIP_INDICATOR_REQ \| USBIP_REQ_RET_DEVLIST);
727	ReqDevList.u32Status = RT_H2N_U32(0);
728	rc = RTTcpWrite(m->hSocket, &ReqDevList, sizeof(ReqDevList));
729	if (RT_SUCCESS(rc))
730	advanceState(kUsbIpRecvState_Hdr);
731	}
732
733	return rc;
734	}
735
736	/**
737	* Advances the state machine to the given state.
738	*
739	* @returns nothing.
740	* @param enmRecvState The new receive state.
741	*/
742	void USBProxyBackendUsbIp::advanceState(USBIPRECVSTATE enmRecvState)
743	{
744	switch (enmRecvState)
745	{
746	case kUsbIpRecvState_None:
747	break;
748	case kUsbIpRecvState_Hdr:
749	{
750	m->cbResidualRecv = sizeof(UsbIpRetDevList);
751	m->pbRecvBuf = (uint8_t *)&m->Scratch.RetDevList;
752	break;
753	}
754	case kUsbIpRecvState_ExportedDevice:
755	{
756	m->cbResidualRecv = sizeof(UsbIpExportedDevice);
757	m->pbRecvBuf = (uint8_t *)&m->Scratch.ExportedDevice;
758	break;
759	}
760	case kUsbIpRecvState_DeviceInterface:
761	{
762	m->cbResidualRecv = sizeof(UsbIpDeviceInterface);
763	m->pbRecvBuf = (uint8_t *)&m->Scratch.DeviceInterface;
764	break;
765	}
766	default:
767	AssertMsgFailed(("Invalid USB/IP receive state %d\n", enmRecvState));
768	return;
769	}
770
771	m->enmRecvState = enmRecvState;
772	}
773
774	/**
775	* Receives data from the USB/IP host and processes it when everything for the current
776	* state was received.
777	*
778	* @returns VBox status code.
779	*/
780	int USBProxyBackendUsbIp::receiveData()
781	{
782	int rc = VINF_SUCCESS;
783	size_t cbRecvd = 0;
784
785	do
786	{
787	rc = RTTcpReadNB(m->hSocket, m->pbRecvBuf, m->cbResidualRecv, &cbRecvd);
788	if (RT_SUCCESS(rc))
789	{
790	m->cbResidualRecv -= cbRecvd;
791	m->pbRecvBuf += cbRecvd;
792	/* In case we received everything for the current state process the data. */
793	if (!m->cbResidualRecv)
794	{
795	rc = processData();
796	if ( RT_SUCCESS(rc)
797	&& m->enmRecvState == kUsbIpRecvState_None)
798	break;
799	}
800	}
801	} while (RT_SUCCESS(rc) && cbRecvd > 0);
802
803	return rc;
804	}
805
806	/**
807	* Processes the data in the scratch buffer based on the current state.
808	*
809	* @returns VBox status code.
810	*/
811	int USBProxyBackendUsbIp::processData()
812	{
813	int rc = VINF_SUCCESS;
814
815	switch (m->enmRecvState)
816	{
817	case kUsbIpRecvState_Hdr:
818	{
819	/* Check that the reply matches our expectations. */
820	if ( RT_N2H_U16(m->Scratch.RetDevList.u16Version) == USBIP_VERSION
821	&& RT_N2H_U16(m->Scratch.RetDevList.u16Cmd) == USBIP_REQ_RET_DEVLIST
822	&& RT_N2H_U32(m->Scratch.RetDevList.u32Status) == USBIP_STATUS_SUCCESS)
823	{
824	/* Populate the number of exported devices in the list and go to the next state. */
825	m->cDevicesLeft = RT_N2H_U32(m->Scratch.RetDevList.u32DevicesExported);
826	if (m->cDevicesLeft)
827	advanceState(kUsbIpRecvState_ExportedDevice);
828	else
829	advanceState(kUsbIpRecvState_None);
830	}
831	else
832	{
833	LogRelMax(10, ("USB/IP: Host sent an invalid reply to the list exported device request (Version: %#x Cmd: %#x Status: %#x)\n",
834	RT_N2H_U16(m->Scratch.RetDevList.u16Version), RT_N2H_U16(m->Scratch.RetDevList.u16Cmd),
835	RT_N2H_U32(m->Scratch.RetDevList.u32Status)));
836	/* Disconnect and start over. */
837	advanceState(kUsbIpRecvState_None);
838	disconnect();
839	rc = VERR_NET_SHUTDOWN;
840	}
841	break;
842	}
843	case kUsbIpRecvState_ExportedDevice:
844	{
845	/* Create a new device and add it to the list. */
846	usbProxyBackendUsbIpExportedDeviceN2H(&m->Scratch.ExportedDevice);
847	rc = addDeviceToList(&m->Scratch.ExportedDevice);
848	if (RT_SUCCESS(rc))
849	{
850	m->cInterfacesLeft = m->Scratch.ExportedDevice.bNumInterfaces;
851	if (m->cInterfacesLeft)
852	advanceState(kUsbIpRecvState_DeviceInterface);
853	else
854	{
855	m->cDevicesLeft--;
856	if (m->cDevicesLeft)
857	advanceState(kUsbIpRecvState_ExportedDevice);
858	else
859	advanceState(kUsbIpRecvState_None);
860	}
861	}
862	break;
863	}
864	case kUsbIpRecvState_DeviceInterface:
865	{
866	/*
867	* If all interfaces for the current device were received receive the next device
868	* if there is another one left, if not we are done with the current request.
869	*/
870	m->cInterfacesLeft--;
871	if (m->cInterfacesLeft)
872	advanceState(kUsbIpRecvState_DeviceInterface);
873	else
874	{
875	m->cDevicesLeft--;
876	if (m->cDevicesLeft)
877	advanceState(kUsbIpRecvState_ExportedDevice);
878	else
879	advanceState(kUsbIpRecvState_None);
880	}
881	break;
882	}
883	case kUsbIpRecvState_None:
884	default:
885	AssertMsgFailed(("Invalid USB/IP receive state %d\n", m->enmRecvState));
886	return VERR_INVALID_STATE;
887	}
888
889	return rc;
890	}
891
892	/**
893	* Creates a new USB device and adds it to the list.
894	*
895	* @returns VBox status code.
896	* @param pDev Pointer to the USB/IP exported device structure to take
897	* the information for the new device from.
898	*/
899	int USBProxyBackendUsbIp::addDeviceToList(PUsbIpExportedDevice pDev)
900	{
901	PUSBDEVICE pNew = (PUSBDEVICE)RTMemAllocZ(sizeof(USBDEVICE));
902	if (!pNew)
903	return VERR_NO_MEMORY;
904
905	pNew->pszManufacturer = RTStrDup("");
906	pNew->pszProduct = RTStrDup("");
907	pNew->pszSerialNumber = NULL;
908	pNew->pszBackend = RTStrDup("usbip");
909
910	/* Make sure the Bus id is 0 terminated. */
911	pDev->szBusId[31] = '\0';
912	int rc = RTStrAPrintf((char **)&pNew->pszAddress, "usbip://%s:%u:%s", m->pszHost, m->uPort, &pDev->szBusId[0]);
913	if (RT_SUCCESS(rc))
914	{
915	pNew->idVendor = pDev->u16VendorId;
916	pNew->idProduct = pDev->u16ProductId;
917	pNew->bcdDevice = pDev->u16BcdDevice;
918	pNew->bDeviceClass = pDev->bDeviceClass;
919	pNew->bDeviceSubClass = pDev->bDeviceSubClass;
920	pNew->bDeviceProtocol = pDev->bDeviceProtocol;
921	pNew->bNumConfigurations = pDev->bNumConfigurations;
922	pNew->enmState = USBDEVICESTATE_USED_BY_HOST_CAPTURABLE;
923	pNew->u64SerialHash = 0;
924	/** @todo: The following is not correct but is required to to get USB testing working
925	* because only the port can be part of a filter (adding the required attributes for the bus
926	* breaks API and ABI compatibility).
927	* Filtering by port number is required for USB testing to connect to the correct device
928	* in case there are multiple ones.
929	*/
930	pNew->bBus = (uint8_t)pDev->u32DevNum;
931	pNew->bPort = (uint8_t)pDev->u32BusNum;
932
933	switch (pDev->u32Speed)
934	{
935	case USBIP_SPEED_LOW:
936	pNew->enmSpeed = USBDEVICESPEED_LOW;
937	pNew->bcdUSB = 1 << 8;
938	break;
939	case USBIP_SPEED_FULL:
940	pNew->enmSpeed = USBDEVICESPEED_FULL;
941	pNew->bcdUSB = 1 << 8;
942	break;
943	case USBIP_SPEED_HIGH:
944	pNew->enmSpeed = USBDEVICESPEED_HIGH;
945	pNew->bcdUSB = 2 << 8;
946	break;
947	case USBIP_SPEED_WIRELESS:
948	pNew->enmSpeed = USBDEVICESPEED_VARIABLE;
949	pNew->bcdUSB = 1 << 8;
950	break;
951	case USBIP_SPEED_SUPER:
952	pNew->enmSpeed = USBDEVICESPEED_SUPER;
953	pNew->bcdUSB = 3 << 8;
954	break;
955	case USBIP_SPEED_UNKNOWN:
956	default:
957	pNew->bcdUSB = 1 << 8;
958	pNew->enmSpeed = USBDEVICESPEED_UNKNOWN;
959	}
960
961	/* link it */
962	pNew->pNext = NULL;
963	pNew->pPrev = *m->ppNext;
964	*m->ppNext = pNew;
965	m->ppNext = &pNew->pNext;
966	m->cDevicesCur++;
967	}
968
969	if (RT_FAILURE(rc))
970	{
971	if (pNew->pszManufacturer)
972	RTStrFree((char *)pNew->pszManufacturer);
973	if (pNew->pszProduct)
974	RTStrFree((char *)pNew->pszProduct);
975	if (pNew->pszBackend)
976	RTStrFree((char *)pNew->pszBackend);
977	if (pNew->pszAddress)
978	RTStrFree((char *)pNew->pszAddress);
979	RTMemFree(pNew);
980	}
981
982	return rc;
983	}
984
985	/**
986	* Compares the given device list with the current one and returns whether it has
987	* changed.
988	*
989	* @returns flag whether the device list has changed compared to the current one.
990	* @param pDevices The device list to compare the current one against.
991	*/
992	bool USBProxyBackendUsbIp::hasDevListChanged(PUSBDEVICE pDevices)
993	{
994	/** @todo */
995	NOREF(pDevices);
996	return true;
997	}
998

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/src-server/generic/USBProxyBackendUsbIp.cpp@ 60755

Download in other formats: