UsbCardReader.cpp@ 98273

Last change on this file since 98273 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 66.7 KB

Line
1	/* $Id: UsbCardReader.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* UsbCardReader - Driver Interface to USB Smart Card Reader emulation.
4	*/
5
6	/*
7	* Copyright (C) 2011-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_USB_CARDREADER
33	#include "LoggingNew.h"
34
35	#include "UsbCardReader.h"
36	#include "ConsoleImpl.h"
37	#include "ConsoleVRDPServer.h"
38
39	#include <VBox/vmm/pdmdrv.h>
40	#include <VBox/vmm/pdmcardreaderinfs.h>
41	#include <VBox/err.h>
42
43	#include <iprt/req.h>
44
45
46	/*********************************************************************************************************************************
47	* Structures and Typedefs *
48	*********************************************************************************************************************************/
49	typedef struct USBCARDREADER USBCARDREADER;
50	typedef struct USBCARDREADER *PUSBCARDREADER;
51
52	struct USBCARDREADER
53	{
54	UsbCardReader *pUsbCardReader;
55
56	PPDMDRVINS pDrvIns;
57
58	PDMICARDREADERDOWN ICardReaderDown;
59	PPDMICARDREADERUP pICardReaderUp;
60
61	/* Thread handling Cmd to card reader */
62	PPDMTHREAD pThrCardReaderCmd;
63	/* Queue handling requests to cardreader */
64	RTREQQUEUE hReqQCardReaderCmd;
65	};
66
67
68	/*
69	* Command queue's callbacks.
70	*/
71
72	static DECLCALLBACK(void) drvCardReaderCmdStatusChange(PUSBCARDREADER pThis,
73	void *pvUser,
74	uint32_t u32Timeout,
75	PDMICARDREADER_READERSTATE *paReaderStats,
76	uint32_t cReaderStats)
77	{
78	LogFlowFunc(("ENTER: pvUser:%p, u32Timeout:%d\n",
79	pvUser, u32Timeout));
80
81	UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
82	if (!pUsbCardReader)
83	{
84	pThis->pICardReaderUp->pfnSetStatusChange(pThis->pICardReaderUp,
85	pvUser, VRDE_SCARD_E_NO_SMARTCARD,
86	paReaderStats, cReaderStats);
87	}
88	else
89	{
90	pUsbCardReader->GetStatusChange(pThis, pvUser, u32Timeout,
91	paReaderStats, cReaderStats);
92	}
93
94	LogFlowFuncLeave();
95	}
96
97
98	static DECLCALLBACK(void) drvCardReaderCmdEstablishContext(PUSBCARDREADER pThis)
99	{
100	LogFlowFunc(("\n"));
101
102	UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
103	if (!pUsbCardReader)
104	{
105	pThis->pICardReaderUp->pfnEstablishContext(pThis->pICardReaderUp,
106	VRDE_SCARD_E_NO_SMARTCARD);
107	}
108	else
109	{
110	pUsbCardReader->EstablishContext(pThis);
111	}
112
113	LogFlowFuncLeave();
114	}
115
116	static DECLCALLBACK(void) drvCardReaderCmdReleaseContext(PUSBCARDREADER pThis,
117	void *pvUser)
118	{
119	LogFlowFunc(("ENTER: pvUser:%p\n",
120	pvUser));
121	NOREF(pvUser);
122
123	UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
124	if (!pUsbCardReader)
125	{
126	/* Do nothing. */
127	}
128	else
129	{
130	pUsbCardReader->ReleaseContext(pThis);
131	}
132
133	LogFlowFuncLeave();
134	}
135
136	static DECLCALLBACK(void) drvCardReaderCmdStatus(PUSBCARDREADER pThis,
137	void *pvUser)
138	{
139	LogFlowFunc(("ENTER: pvUser:%p\n",
140	pvUser));
141
142	UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
143	if (!pUsbCardReader)
144	{
145	pThis->pICardReaderUp->pfnStatus(pThis->pICardReaderUp,
146	pvUser,
147	VRDE_SCARD_E_NO_SMARTCARD,
148	/* pszReaderName */ NULL,
149	/* cchReaderName */ 0,
150	/* u32CardState */ 0,
151	/* u32Protocol */ 0,
152	/* pu8Atr */ 0,
153	/* cbAtr */ 0);
154	}
155	else
156	{
157	pUsbCardReader->Status(pThis, pvUser);
158	}
159
160	LogFlowFuncLeave();
161	}
162
163	static DECLCALLBACK(void) drvCardReaderCmdConnect(PUSBCARDREADER pThis,
164	void *pvUser,
165	const char *pcszCardReaderName,
166	uint32_t u32ShareMode,
167	uint32_t u32PreferredProtocols)
168	{
169	LogFlowFunc(("ENTER: pvUser:%p, pcszCardReaderName:%s, u32ShareMode:%RX32, u32PreferredProtocols:%RX32\n",
170	pvUser, pcszCardReaderName, u32ShareMode, u32PreferredProtocols));
171
172	UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
173	if (!pUsbCardReader)
174	{
175	pThis->pICardReaderUp->pfnConnect(pThis->pICardReaderUp,
176	pvUser,
177	VRDE_SCARD_E_NO_SMARTCARD,
178	0);
179	}
180	else
181	{
182	pUsbCardReader->Connect(pThis, pvUser, pcszCardReaderName,
183	u32ShareMode, u32PreferredProtocols);
184	}
185
186	LogFlowFuncLeave();
187	}
188
189	static DECLCALLBACK(void) drvCardReaderCmdDisconnect(PUSBCARDREADER pThis,
190	void *pvUser,
191	uint32_t u32Disposition)
192	{
193	LogFlowFunc(("ENTER: pvUser:%p, u32Disposition:%RX32\n",
194	pvUser, u32Disposition));
195
196	UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
197	if (!pUsbCardReader)
198	{
199	pThis->pICardReaderUp->pfnDisconnect(pThis->pICardReaderUp,
200	pvUser,
201	VRDE_SCARD_E_NO_SMARTCARD);
202	}
203	else
204	{
205	pUsbCardReader->Disconnect(pThis, pvUser, u32Disposition);
206	}
207
208	LogFlowFuncLeave();
209	}
210
211	static DECLCALLBACK(void) drvCardReaderCmdTransmit(PUSBCARDREADER pThis,
212	void *pvUser,
213	PDMICARDREADER_IO_REQUEST *pioSendRequest,
214	uint8_t *pu8SendBuffer,
215	uint32_t cbSendBuffer,
216	uint32_t cbRecvBuffer)
217	{
218	LogFlowFunc(("ENTER: pvUser:%p, pioSendRequest:%p, pu8SendBuffer:%p, cbSendBuffer:%d, cbRecvBuffer:%d\n",
219	pvUser, pioSendRequest, pu8SendBuffer, cbSendBuffer, cbRecvBuffer));
220
221	UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
222	if (!pUsbCardReader)
223	{
224	pThis->pICardReaderUp->pfnTransmit(pThis->pICardReaderUp,
225	pvUser,
226	VRDE_SCARD_E_NO_SMARTCARD,
227	/* pioRecvPci */ NULL,
228	/* pu8RecvBuffer */ NULL,
229	/* cbRecvBuffer*/ 0);
230	}
231	else
232	{
233	pUsbCardReader->Transmit(pThis, pvUser, pioSendRequest,
234	pu8SendBuffer, cbSendBuffer, cbRecvBuffer);
235	}
236
237	/* Clean up buffers allocated by driver */
238	RTMemFree(pioSendRequest);
239	RTMemFree(pu8SendBuffer);
240
241	LogFlowFuncLeave();
242	}
243
244	static DECLCALLBACK(void) drvCardReaderCmdGetAttr(PUSBCARDREADER pThis,
245	void *pvUser,
246	uint32_t u32AttrId,
247	uint32_t cbAttrib)
248	{
249	LogFlowFunc(("ENTER: pvUser:%p, u32AttrId:%RX32, cbAttrib:%d\n",
250	pvUser, u32AttrId, cbAttrib));
251
252	UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
253	if (!pUsbCardReader)
254	{
255	pThis->pICardReaderUp->pfnGetAttrib(pThis->pICardReaderUp,
256	pvUser,
257	VRDE_SCARD_E_NO_SMARTCARD,
258	u32AttrId,
259	/* pvAttrib */ NULL,
260	/* cbAttrib */ 0);
261	}
262	else
263	{
264	pUsbCardReader->GetAttrib(pThis, pvUser, u32AttrId, cbAttrib);
265	}
266
267	LogFlowFuncLeave();
268	}
269
270	static DECLCALLBACK(void) drvCardReaderCmdSetAttr(PUSBCARDREADER pThis,
271	void *pvUser,
272	uint32_t u32AttrId,
273	void *pvAttrib,
274	uint32_t cbAttrib)
275	{
276	LogFlowFunc(("ENTER: pvUser:%p, u32AttrId:%RX32, pvAttrib:%p, cbAttrib:%d\n",
277	pvUser, u32AttrId, pvAttrib, cbAttrib));
278
279	UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
280	if (!pUsbCardReader)
281	{
282	pThis->pICardReaderUp->pfnSetAttrib(pThis->pICardReaderUp,
283	pvUser,
284	VRDE_SCARD_E_NO_SMARTCARD,
285	u32AttrId);
286	}
287	else
288	{
289	pUsbCardReader->SetAttrib(pThis, pvUser, u32AttrId, (uint8_t *)pvAttrib, cbAttrib);
290	}
291
292	/* Clean up buffers allocated by driver */
293	RTMemFree(pvAttrib);
294
295	LogFlowFuncLeave();
296	}
297
298	static DECLCALLBACK(void) drvCardReaderCmdControl(PUSBCARDREADER pThis,
299	void *pvUser,
300	uint32_t u32ControlCode,
301	void *pvInBuffer,
302	uint32_t cbInBuffer,
303	uint32_t cbOutBuffer)
304	{
305	LogFlowFunc(("ENTER: pvUser:%p, u32ControlCode:%RX32, pvInBuffer:%p, cbInBuffer:%d, cbOutBuffer:%d\n",
306	pvUser, u32ControlCode, pvInBuffer, cbInBuffer, cbOutBuffer));
307
308	UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
309	if (!pUsbCardReader)
310	{
311	pThis->pICardReaderUp->pfnControl(pThis->pICardReaderUp,
312	pvUser,
313	VRDE_SCARD_E_NO_SMARTCARD,
314	u32ControlCode,
315	/* pvOutBuffer */ NULL,
316	/* cbOutBuffer */ 0);
317	}
318	else
319	{
320	pUsbCardReader->Control(pThis, pvUser, u32ControlCode,
321	(uint8_t *)pvInBuffer, cbInBuffer, cbOutBuffer);
322	}
323
324	/* Clean up buffers allocated by driver */
325	RTMemFree(pvInBuffer);
326
327	LogFlowFuncLeave();
328	}
329
330
331	/*
332	* PDMICARDREADERDOWN - interface
333	*/
334
335	static DECLCALLBACK(int) drvCardReaderDownConnect(PPDMICARDREADERDOWN pInterface,
336	void *pvUser,
337	const char *pcszCardReaderName,
338	uint32_t u32ShareMode,
339	uint32_t u32PreferredProtocols)
340	{
341	AssertPtrReturn(pInterface, VERR_INVALID_PARAMETER);
342	LogFlowFunc(("ENTER: pcszCardReaderName:%s, pvUser:%p, u32ShareMode:%RX32, u32PreferredProtocols:%RX32\n",
343	pcszCardReaderName, pvUser, u32ShareMode, u32PreferredProtocols));
344	PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
345	int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID \| RTREQFLAGS_NO_WAIT,
346	(PFNRT)drvCardReaderCmdConnect, 5,
347	pThis, pvUser, pcszCardReaderName, u32ShareMode, u32PreferredProtocols);
348	AssertRC(rc);
349	LogFlowFunc(("LEAVE: %Rrc\n", rc));
350	return rc;
351	}
352
353	static DECLCALLBACK(int) drvCardReaderDownDisconnect(PPDMICARDREADERDOWN pInterface,
354	void *pvUser,
355	uint32_t u32Disposition)
356	{
357	AssertPtrReturn(pInterface, VERR_INVALID_PARAMETER);
358	LogFlowFunc(("ENTER: pvUser:%p, u32Disposition:%RX32\n",
359	pvUser, u32Disposition));
360	PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
361	int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID \| RTREQFLAGS_NO_WAIT,
362	(PFNRT)drvCardReaderCmdDisconnect, 3,
363	pThis, pvUser, u32Disposition);
364	AssertRC(rc);
365	LogFlowFunc(("LEAVE: %Rrc\n", rc));
366	return rc;
367	}
368
369	static DECLCALLBACK(int) drvCardReaderDownEstablishContext(PPDMICARDREADERDOWN pInterface)
370	{
371	AssertPtrReturn(pInterface, VERR_INVALID_PARAMETER);
372	LogFlowFunc(("ENTER:\n"));
373	PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
374	int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID \| RTREQFLAGS_NO_WAIT,
375	(PFNRT)drvCardReaderCmdEstablishContext, 1,
376	pThis);
377	AssertRC(rc);
378	LogFlowFunc(("LEAVE: %Rrc\n", rc));
379	return rc;
380	}
381
382	static DECLCALLBACK(int) drvCardReaderDownReleaseContext(PPDMICARDREADERDOWN pInterface,
383	void *pvUser)
384	{
385	AssertPtrReturn(pInterface, VERR_INVALID_PARAMETER);
386	LogFlowFunc(("ENTER: pvUser:%p\n",
387	pvUser));
388	PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
389	/** @todo Device calls this when the driver already destroyed. */
390	if (pThis->hReqQCardReaderCmd == NIL_RTREQQUEUE)
391	{
392	LogFlowFunc(("LEAVE: device already deleted.\n"));
393	return VINF_SUCCESS;
394	}
395
396	int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID \| RTREQFLAGS_NO_WAIT,
397	(PFNRT)drvCardReaderCmdReleaseContext, 2,
398	pThis, pvUser);
399	AssertRC(rc);
400	LogFlowFunc(("LEAVE: %Rrc\n", rc));
401	return rc;
402	}
403
404	static DECLCALLBACK(int) drvCardReaderDownStatus(PPDMICARDREADERDOWN pInterface,
405	void *pvUser,
406	uint32_t cchReaderName,
407	uint32_t cbAtrLen)
408	{
409	AssertPtrReturn(pInterface, VERR_INVALID_PARAMETER);
410	LogFlowFunc(("ENTER: pvUser:%p, cchReaderName:%d, cbAtrLen:%d\n",
411	pvUser, cchReaderName, cbAtrLen));
412	NOREF(cchReaderName);
413	NOREF(cbAtrLen);
414	PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
415	int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID \| RTREQFLAGS_NO_WAIT,
416	(PFNRT)drvCardReaderCmdStatus, 2,
417	pThis, pvUser);
418	AssertRC(rc);
419	LogFlowFunc(("LEAVE: %Rrc\n", rc));
420	return rc;
421	}
422
423	static DECLCALLBACK(int) drvCardReaderDownGetStatusChange(PPDMICARDREADERDOWN pInterface,
424	void *pvUser,
425	uint32_t u32Timeout,
426	PDMICARDREADER_READERSTATE *paReaderStats,
427	uint32_t cReaderStats)
428	{
429	AssertPtrReturn(pInterface, VERR_INVALID_PARAMETER);
430	LogFlowFunc(("ENTER: pvUser:%p, u32Timeout:%d, cReaderStats:%d\n",
431	pvUser, u32Timeout, cReaderStats));
432	PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
433	int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID \| RTREQFLAGS_NO_WAIT,
434	(PFNRT)drvCardReaderCmdStatusChange, 5,
435	pThis, pvUser, u32Timeout, paReaderStats, cReaderStats);
436	AssertRC(rc);
437	LogFlowFunc(("LEAVE: %Rrc\n", rc));
438	return rc;
439	}
440
441	static DECLCALLBACK(int) drvCardReaderDownBeginTransaction(PPDMICARDREADERDOWN pInterface,
442	void *pvUser)
443	{
444	RT_NOREF(pvUser);
445	AssertPtrReturn(pInterface, VERR_INVALID_PARAMETER);
446	LogFlowFunc(("ENTER: pvUser:%p\n",
447	pvUser));
448	PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown); NOREF(pThis);
449	int rc = VERR_NOT_SUPPORTED;
450	AssertRC(rc);
451	LogFlowFunc(("LEAVE: %Rrc\n", rc));
452	return rc;
453	}
454
455	static DECLCALLBACK(int) drvCardReaderDownEndTransaction(PPDMICARDREADERDOWN pInterface,
456	void *pvUser,
457	uint32_t u32Disposition)
458	{
459	RT_NOREF(pvUser, u32Disposition);
460	AssertPtrReturn(pInterface, VERR_INVALID_PARAMETER);
461	LogFlowFunc(("ENTER: pvUser:%p, u32Disposition:%RX32\n",
462	pvUser, u32Disposition));
463	PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown); NOREF(pThis);
464	int rc = VERR_NOT_SUPPORTED;
465	AssertRC(rc);
466	LogFlowFunc(("LEAVE: %Rrc\n", rc));
467	return rc;
468	}
469
470	static DECLCALLBACK(int) drvCardReaderDownTransmit(PPDMICARDREADERDOWN pInterface,
471	void *pvUser,
472	const PDMICARDREADER_IO_REQUEST *pioSendRequest,
473	const uint8_t *pu8SendBuffer,
474	uint32_t cbSendBuffer,
475	uint32_t cbRecvBuffer)
476	{
477	AssertPtrReturn(pInterface, VERR_INVALID_PARAMETER);
478	LogFlowFunc(("ENTER: pvUser:%p, pioSendRequest:%p, pu8SendBuffer:%p, cbSendBuffer:%d, cbRecvBuffer:%d\n",
479	pvUser, pioSendRequest, pu8SendBuffer, cbSendBuffer, cbRecvBuffer));
480	PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
481	uint8_t *pu8SendBufferCopy = NULL;
482	if ( pu8SendBuffer
483	&& cbSendBuffer)
484	{
485	pu8SendBufferCopy = (uint8_t *)RTMemDup(pu8SendBuffer, cbSendBuffer);
486	if (!pu8SendBufferCopy)
487	{
488	return VERR_NO_MEMORY;
489	}
490	}
491	PDMICARDREADER_IO_REQUEST *pioSendRequestCopy = NULL;
492	if (pioSendRequest)
493	{
494	pioSendRequestCopy = (PDMICARDREADER_IO_REQUEST *)RTMemDup(pioSendRequest, pioSendRequest->cbPciLength);
495	if (!pioSendRequestCopy)
496	{
497	RTMemFree(pu8SendBufferCopy);
498	return VERR_NO_MEMORY;
499	}
500	}
501	int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0,RTREQFLAGS_VOID \| RTREQFLAGS_NO_WAIT,
502	(PFNRT)drvCardReaderCmdTransmit, 6,
503	pThis, pvUser, pioSendRequestCopy, pu8SendBufferCopy, cbSendBuffer, cbRecvBuffer);
504	AssertRC(rc);
505	LogFlowFunc(("LEAVE: %Rrc\n", rc));
506	return rc;
507	}
508
509	static DECLCALLBACK(int) drvCardReaderDownGetAttr(PPDMICARDREADERDOWN pInterface,
510	void *pvUser,
511	uint32_t u32AttribId,
512	uint32_t cbAttrib)
513	{
514	AssertPtrReturn(pInterface, VERR_INVALID_PARAMETER);
515	LogFlowFunc(("ENTER: pvUser:%p, u32AttribId:%RX32, cbAttrib:%d\n",
516	pvUser, u32AttribId, cbAttrib));
517	PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
518	int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID \| RTREQFLAGS_NO_WAIT,
519	(PFNRT)drvCardReaderCmdGetAttr, 4,
520	pThis, pvUser, u32AttribId, cbAttrib);
521	AssertRC(rc);
522	LogFlowFunc(("LEAVE: %Rrc\n", rc));
523	return rc;
524	}
525
526	static DECLCALLBACK(int) drvCardReaderDownSetAttr(PPDMICARDREADERDOWN pInterface,
527	void *pvUser,
528	uint32_t u32AttribId,
529	const void *pvAttrib,
530	uint32_t cbAttrib)
531	{
532	AssertPtrReturn(pInterface, VERR_INVALID_PARAMETER);
533	LogFlowFunc(("ENTER: pvUser:%p, u32AttribId:%RX32, pvAttrib:%p, cbAttrib:%d\n",
534	pvUser, u32AttribId, pvAttrib, cbAttrib));
535	PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
536	void *pvAttribCopy = NULL;
537	if ( pvAttrib
538	&& cbAttrib)
539	{
540	pvAttribCopy = RTMemDup(pvAttrib, cbAttrib);
541	AssertPtrReturn(pvAttribCopy, VERR_NO_MEMORY);
542	}
543	int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID \| RTREQFLAGS_NO_WAIT,
544	(PFNRT)drvCardReaderCmdSetAttr, 5,
545	pThis, pvUser, u32AttribId, pvAttribCopy, cbAttrib);
546	AssertRC(rc);
547	LogFlowFunc(("LEAVE: %Rrc\n", rc));
548	return rc;
549	}
550
551	static DECLCALLBACK(int) drvCardReaderDownControl(PPDMICARDREADERDOWN pInterface,
552	void *pvUser,
553	uint32_t u32ControlCode,
554	const void *pvInBuffer,
555	uint32_t cbInBuffer,
556	uint32_t cbOutBuffer)
557	{
558	AssertPtrReturn(pInterface, VERR_INVALID_PARAMETER);
559	LogFlowFunc(("ENTER: pvUser:%p, u32ControlCode:%RX32 pvInBuffer:%p, cbInBuffer:%d, cbOutBuffer:%d\n",
560	pvUser, u32ControlCode, pvInBuffer, cbInBuffer, cbOutBuffer));
561	PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
562	void *pvInBufferCopy = NULL;
563	if ( pvInBuffer
564	&& cbInBuffer)
565	{
566	pvInBufferCopy = RTMemDup(pvInBuffer, cbInBuffer);
567	AssertReturn(pvInBufferCopy, VERR_NO_MEMORY);
568	}
569	int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID \| RTREQFLAGS_NO_WAIT,
570	(PFNRT)drvCardReaderCmdControl, 6,
571	pThis, pvUser, u32ControlCode, pvInBufferCopy, cbInBuffer, cbOutBuffer);
572	AssertRC(rc);
573	LogFlowFunc(("LEAVE: %Rrc\n", rc));
574	return rc;
575	}
576
577
578	/*
579	* Cardreader driver thread routines
580	*/
581	static DECLCALLBACK(int) drvCardReaderThreadCmd(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
582	{
583	int rc = VINF_SUCCESS;
584	PUSBCARDREADER pThis = PDMINS_2_DATA(pDrvIns, PUSBCARDREADER);
585
586	LogFlowFunc(("ENTER: pDrvIns:%d, state %d\n", pDrvIns->iInstance, pThread->enmState));
587
588	if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
589	{
590	LogFlowFunc(("LEAVE: INITIALIZING: VINF_SUCCESS\n"));
591	return VINF_SUCCESS;
592	}
593
594	while (pThread->enmState == PDMTHREADSTATE_RUNNING)
595	{
596	rc = RTReqQueueProcess(pThis->hReqQCardReaderCmd, RT_INDEFINITE_WAIT);
597
598	AssertMsg(rc == VWRN_STATE_CHANGED,
599	("Left RTReqProcess and error code is not VWRN_STATE_CHANGED rc=%Rrc\n",
600	rc));
601	}
602
603	LogFlowFunc(("LEAVE: %Rrc\n", rc));
604	return rc;
605	}
606
607	static DECLCALLBACK(int) drvCardReaderWakeupFunc(PUSBCARDREADER pThis)
608	{
609	NOREF(pThis);
610	/* Returning a VINF_* will cause RTReqQueueProcess return. */
611	return VWRN_STATE_CHANGED;
612	}
613
614	static DECLCALLBACK(int) drvCardReaderThreadCmdWakeup(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
615	{
616	RT_NOREF(pThread);
617	LogFlowFunc(("ENTER: pDrvIns:%i\n", pDrvIns->iInstance));
618	PUSBCARDREADER pThis = PDMINS_2_DATA(pDrvIns, PUSBCARDREADER);
619
620	AssertReturn(pThis->hReqQCardReaderCmd != NIL_RTREQQUEUE, VERR_INVALID_STATE);
621
622	PRTREQ pReq;
623	int rc = RTReqQueueCall(pThis->hReqQCardReaderCmd, &pReq, 10000, (PFNRT)drvCardReaderWakeupFunc, 1, pThis);
624	AssertMsgRC(rc, ("Inserting request into queue failed rc=%Rrc\n", rc));
625
626	if (RT_SUCCESS(rc))
627	RTReqRelease(pReq);
628	/** @todo handle VERR_TIMEOUT */
629
630	return rc;
631	}
632
633
634	/*
635	* USB Card reader driver implementation.
636	*/
637
638	UsbCardReader::UsbCardReader(Console *console)
639	:
640	mpDrv(NULL),
641	mParent(console),
642	m_pRemote(NULL)
643	{
644	LogFlowFunc(("\n"));
645	}
646
647	UsbCardReader::~UsbCardReader()
648	{
649	LogFlowFunc(("mpDrv %p\n", mpDrv));
650	if (mpDrv)
651	{
652	mpDrv->pUsbCardReader = NULL;
653	mpDrv = NULL;
654	}
655	}
656
657	typedef struct UCRREMOTEREADER
658	{
659	bool fAvailable;
660	char szReaderName[1024];
661
662	bool fHandle;
663	VRDESCARDHANDLE hCard;
664	} UCRREMOTEREADER;
665
666	struct UCRREMOTE
667	{
668	UsbCardReader *pUsbCardReader;
669
670	/* The remote identifiers. */
671	uint32_t u32ClientId;
672	uint32_t u32DeviceId;
673
674	bool fContext;
675	VRDESCARDCONTEXT context;
676
677	/* Possible a few readers. Currently only one. */
678	UCRREMOTEREADER reader;
679	};
680
681	typedef struct UCRREQCTX
682	{
683	UCRREMOTE *pRemote;
684	uint32_t u32Function;
685	void *pvUser;
686	union
687	{
688	struct
689	{
690	PDMICARDREADER_READERSTATE *paReaderStats;
691	uint32_t cReaderStats;
692	} GetStatusChange;
693	struct
694	{
695	uint32_t u32AttrId;
696	} GetAttrib;
697	struct
698	{
699	uint32_t u32AttrId;
700	} SetAttrib;
701	struct
702	{
703	uint32_t u32ControlCode;
704	} Control;
705	} u;
706	} UCRREQCTX;
707
708	int UsbCardReader::vrdeSCardRequest(void pvUser, uint32_t u32Function, const void pvData, uint32_t cbData)
709	{
710	int rc = mParent->i_consoleVRDPServer()->SCardRequest(pvUser, u32Function, pvData, cbData);
711	LogFlowFunc(("%d %Rrc\n", u32Function, rc));
712	return rc;
713	}
714
715	int UsbCardReader::VRDENotify(uint32_t u32Id, void *pvData, uint32_t cbData)
716	{
717	RT_NOREF(cbData);
718	int rc = VINF_SUCCESS;
719
720	switch (u32Id)
721	{
722	case VRDE_SCARD_NOTIFY_ATTACH:
723	{
724	VRDESCARDNOTIFYATTACH p = (VRDESCARDNOTIFYATTACH )pvData;
725	Assert(cbData == sizeof(VRDESCARDNOTIFYATTACH));
726
727	LogFlowFunc(("[%d,%d]\n", p->u32ClientId, p->u32DeviceId));
728
729	/* Add this remote instance, which allow access to card readers attached to the client, to the list.
730	* @todo currently only one device is allowed.
731	*/
732	if (m_pRemote)
733	{
734	AssertFailed();
735	rc = VERR_NOT_SUPPORTED;
736	break;
737	}
738	UCRREMOTE pRemote = (UCRREMOTE )RTMemAllocZ(sizeof(UCRREMOTE));
739	if (pRemote == NULL)
740	{
741	rc = VERR_NO_MEMORY;
742	break;
743	}
744
745	pRemote->pUsbCardReader = this;
746	pRemote->u32ClientId = p->u32ClientId;
747	pRemote->u32DeviceId = p->u32DeviceId;
748
749	m_pRemote = pRemote;
750
751	/* Try to establish a context. */
752	VRDESCARDESTABLISHCONTEXTREQ req;
753	req.u32ClientId = m_pRemote->u32ClientId;
754	req.u32DeviceId = m_pRemote->u32DeviceId;
755
756	rc = vrdeSCardRequest(m_pRemote, VRDE_SCARD_FN_ESTABLISHCONTEXT, &req, sizeof(req));
757
758	LogFlowFunc(("sent ESTABLISHCONTEXT\n"));
759	} break;
760
761	case VRDE_SCARD_NOTIFY_DETACH:
762	{
763	VRDESCARDNOTIFYDETACH p = (VRDESCARDNOTIFYDETACH )pvData; NOREF(p);
764	Assert(cbData == sizeof(VRDESCARDNOTIFYDETACH));
765
766	/** @todo Just free. There should be no pending requests, because VRDP cancels them. */
767	RTMemFree(m_pRemote);
768	m_pRemote = NULL;
769	} break;
770
771	default:
772	rc = VERR_INVALID_PARAMETER;
773	AssertFailed();
774	break;
775	}
776
777	return rc;
778	}
779
780	int UsbCardReader::VRDEResponse(int rcRequest, void pvUser, uint32_t u32Function, void pvData, uint32_t cbData)
781	{
782	RT_NOREF(cbData);
783	int rc = VINF_SUCCESS;
784
785	LogFlowFunc(("%Rrc %p %u %p %u\n",
786	rcRequest, pvUser, u32Function, pvData, cbData));
787
788	switch (u32Function)
789	{
790	case VRDE_SCARD_FN_ESTABLISHCONTEXT:
791	{
792	Assert(cbData == sizeof(VRDESCARDESTABLISHCONTEXTRSP) \|\| RT_FAILURE(rcRequest));
793	VRDESCARDESTABLISHCONTEXTRSP pRsp = (VRDESCARDESTABLISHCONTEXTRSP )pvData;
794	UCRREMOTE pRemote = (UCRREMOTE )pvUser;
795
796	/* Check if the context was created. */
797	Assert(!pRemote->fContext);
798	if ( RT_SUCCESS(rcRequest)
799	&& pRsp->u32ReturnCode == VRDE_SCARD_S_SUCCESS)
800	{
801	pRemote->fContext = true;
802	pRemote->context = pRsp->Context;
803
804	LogFlowFunc(("ESTABLISHCONTEXT success\n"));
805
806	/* Now list readers attached to the remote client. */
807	VRDESCARDLISTREADERSREQ req;
808	req.Context = pRemote->context;
809
810	rc = vrdeSCardRequest(pRemote, VRDE_SCARD_FN_LISTREADERS, &req, sizeof(req));
811	}
812	} break;
813
814	case VRDE_SCARD_FN_LISTREADERS:
815	{
816	Assert(cbData == sizeof(VRDESCARDLISTREADERSRSP) \|\| RT_FAILURE(rcRequest));
817	VRDESCARDLISTREADERSRSP pRsp = (VRDESCARDLISTREADERSRSP )pvData;
818	UCRREMOTE pRemote = (UCRREMOTE )pvUser;
819
820	Assert(pRemote->fContext);
821	if ( RT_SUCCESS(rcRequest)
822	&& pRsp->u32ReturnCode == VRDE_SCARD_S_SUCCESS
823	&& pRemote->fContext)
824	{
825	LogFlowFunc(("LISTREADERS: cReaders %d\n",
826	pRsp->cReaders));
827
828	uint32_t i;
829	for (i = 0; i < pRsp->cReaders; i++)
830	{
831	LogFlowFunc(("LISTREADERS: [%d] [%s]\n",
832	i, pRsp->apszNames[i]));
833
834	/** @todo only the first reader is supported. */
835	if (i != 0)
836	{
837	continue;
838	}
839
840	RTStrCopy(pRemote->reader.szReaderName, sizeof(pRemote->reader.szReaderName), pRsp->apszNames[i]);
841	pRemote->reader.fHandle = false;
842	pRemote->reader.fAvailable = true;
843	}
844	}
845	} break;
846
847	case VRDE_SCARD_FN_RELEASECONTEXT:
848	{
849	Assert(cbData == sizeof(VRDESCARDRELEASECONTEXTRSP) \|\| RT_FAILURE(rcRequest));
850	VRDESCARDRELEASECONTEXTRSP pRsp = (VRDESCARDRELEASECONTEXTRSP )pvData; NOREF(pRsp);
851	UCRREQCTX pCtx = (UCRREQCTX )pvUser; NOREF(pCtx);
852
853	Assert(pCtx->u32Function == u32Function);
854
855	LogFlowFunc(("RELEASECONTEXT completed\n"));
856
857	/* No notification is expected here by the caller. */
858	Assert(!m_pRemote->fContext);
859	} break;
860
861	case VRDE_SCARD_FN_GETSTATUSCHANGE:
862	{
863	Assert(cbData == sizeof(VRDESCARDGETSTATUSCHANGERSP) \|\| RT_FAILURE(rcRequest));
864	VRDESCARDGETSTATUSCHANGERSP pRsp = (VRDESCARDGETSTATUSCHANGERSP )pvData;
865	UCRREQCTX pCtx = (UCRREQCTX )pvUser;
866
867	Assert(pCtx->u32Function == u32Function);
868
869	LogFlowFunc(("GETSTATUSCHANGE\n"));
870
871	uint32_t rcCard;
872	if (RT_FAILURE(rcRequest))
873	{
874	rcCard = VRDE_SCARD_E_NO_SMARTCARD;
875	}
876	else
877	{
878	rcCard = pRsp->u32ReturnCode;
879
880	if (pRsp->u32ReturnCode == VRDE_SCARD_S_SUCCESS)
881	{
882	uint32_t i;
883	for (i = 0; i < pRsp->cReaders; i++)
884	{
885	LogFlowFunc(("GETSTATUSCHANGE: [%d] %RX32\n",
886	i, pRsp->aReaderStates[i].u32EventState));
887
888	/** @todo only the first reader is supported. */
889	if (i != 0)
890	{
891	continue;
892	}
893
894	if (i >= pCtx->u.GetStatusChange.cReaderStats)
895	{
896	continue;
897	}
898
899	pCtx->u.GetStatusChange.paReaderStats[i].u32EventState = pRsp->aReaderStates[i].u32EventState;
900	pCtx->u.GetStatusChange.paReaderStats[i].cbAtr = pRsp->aReaderStates[i].u32AtrLength > 36?
901	36:
902	pRsp->aReaderStates[i].u32AtrLength;
903	memcpy(pCtx->u.GetStatusChange.paReaderStats[i].au8Atr,
904	pRsp->aReaderStates[i].au8Atr,
905	pCtx->u.GetStatusChange.paReaderStats[i].cbAtr);
906	}
907	}
908	}
909
910	mpDrv->pICardReaderUp->pfnSetStatusChange(mpDrv->pICardReaderUp,
911	pCtx->pvUser,
912	rcCard,
913	pCtx->u.GetStatusChange.paReaderStats,
914	pCtx->u.GetStatusChange.cReaderStats);
915
916	RTMemFree(pCtx);
917	} break;
918
919	case VRDE_SCARD_FN_CANCEL:
920	{
921	Assert(cbData == sizeof(VRDESCARDCANCELRSP) \|\| RT_FAILURE(rcRequest));
922	VRDESCARDCANCELRSP pRsp = (VRDESCARDCANCELRSP )pvData; NOREF(pRsp);
923	UCRREQCTX pCtx = (UCRREQCTX )pvUser; NOREF(pCtx);
924
925	Assert(pCtx->u32Function == u32Function);
926
927	LogFlowFunc(("CANCEL\n"));
928	} break;
929
930	case VRDE_SCARD_FN_CONNECT:
931	{
932	Assert(cbData == sizeof(VRDESCARDCONNECTRSP) \|\| RT_FAILURE(rcRequest));
933	VRDESCARDCONNECTRSP pRsp = (VRDESCARDCONNECTRSP )pvData;
934	UCRREQCTX pCtx = (UCRREQCTX )pvUser;
935
936	Assert(pCtx->u32Function == u32Function);
937
938	LogFlowFunc(("CONNECT\n"));
939
940	uint32_t u32ActiveProtocol = 0;
941	uint32_t rcCard;
942
943	if (RT_FAILURE(rcRequest))
944	{
945	rcCard = VRDE_SCARD_E_NO_SMARTCARD;
946	}
947	else
948	{
949	rcCard = pRsp->u32ReturnCode;
950
951	if (pRsp->u32ReturnCode == VRDE_SCARD_S_SUCCESS)
952	{
953	u32ActiveProtocol = pRsp->u32ActiveProtocol;
954
955	Assert(!m_pRemote->reader.fHandle);
956	m_pRemote->reader.hCard = pRsp->hCard;
957	m_pRemote->reader.fHandle = true;
958	}
959	}
960
961	mpDrv->pICardReaderUp->pfnConnect(mpDrv->pICardReaderUp,
962	pCtx->pvUser,
963	rcCard,
964	u32ActiveProtocol);
965
966	RTMemFree(pCtx);
967	} break;
968
969	case VRDE_SCARD_FN_RECONNECT:
970	{
971	Assert(cbData == sizeof(VRDESCARDRECONNECTRSP) \|\| RT_FAILURE(rcRequest));
972	VRDESCARDRECONNECTRSP pRsp = (VRDESCARDRECONNECTRSP )pvData; NOREF(pRsp);
973	UCRREQCTX pCtx = (UCRREQCTX )pvUser; NOREF(pCtx);
974
975	Assert(pCtx->u32Function == u32Function);
976
977	LogFlowFunc(("RECONNECT\n"));
978	} break;
979
980	case VRDE_SCARD_FN_DISCONNECT:
981	{
982	Assert(cbData == sizeof(VRDESCARDDISCONNECTRSP) \|\| RT_FAILURE(rcRequest));
983	VRDESCARDDISCONNECTRSP pRsp = (VRDESCARDDISCONNECTRSP )pvData;
984	UCRREQCTX pCtx = (UCRREQCTX )pvUser;
985
986	Assert(pCtx->u32Function == u32Function);
987
988	LogFlowFunc(("DISCONNECT\n"));
989
990	Assert(!pCtx->pRemote->reader.fHandle);
991
992	uint32_t rcCard;
993
994	if (RT_FAILURE(rcRequest))
995	{
996	rcCard = VRDE_SCARD_E_NO_SMARTCARD;
997	}
998	else
999	{
1000	rcCard = pRsp->u32ReturnCode;
1001	}
1002
1003	mpDrv->pICardReaderUp->pfnDisconnect(mpDrv->pICardReaderUp,
1004	pCtx->pvUser,
1005	rcCard);
1006
1007	RTMemFree(pCtx);
1008	} break;
1009
1010	case VRDE_SCARD_FN_BEGINTRANSACTION:
1011	{
1012	Assert(cbData == sizeof(VRDESCARDBEGINTRANSACTIONRSP) \|\| RT_FAILURE(rcRequest));
1013	VRDESCARDBEGINTRANSACTIONRSP pRsp = (VRDESCARDBEGINTRANSACTIONRSP )pvData; NOREF(pRsp);
1014	UCRREQCTX pCtx = (UCRREQCTX )pvUser; NOREF(pCtx);
1015
1016	Assert(pCtx->u32Function == u32Function);
1017
1018	LogFlowFunc(("BEGINTRANSACTION\n"));
1019	} break;
1020
1021	case VRDE_SCARD_FN_ENDTRANSACTION:
1022	{
1023	Assert(cbData == sizeof(VRDESCARDENDTRANSACTIONRSP) \|\| RT_FAILURE(rcRequest));
1024	VRDESCARDENDTRANSACTIONRSP pRsp = (VRDESCARDENDTRANSACTIONRSP )pvData; NOREF(pRsp);
1025	UCRREQCTX pCtx = (UCRREQCTX )pvUser; NOREF(pCtx);
1026
1027	Assert(pCtx->u32Function == u32Function);
1028
1029	LogFlowFunc(("ENDTRANSACTION\n"));
1030	} break;
1031
1032	case VRDE_SCARD_FN_STATE:
1033	{
1034	Assert(cbData == sizeof(VRDESCARDSTATERSP) \|\| RT_FAILURE(rcRequest));
1035	VRDESCARDSTATERSP pRsp = (VRDESCARDSTATERSP )pvData; NOREF(pRsp);
1036	UCRREQCTX pCtx = (UCRREQCTX )pvUser; NOREF(pCtx);
1037
1038	Assert(pCtx->u32Function == u32Function);
1039
1040	LogFlowFunc(("STATE\n"));
1041	} break;
1042
1043	case VRDE_SCARD_FN_STATUS:
1044	{
1045	Assert(cbData == sizeof(VRDESCARDSTATUSRSP) \|\| RT_FAILURE(rcRequest));
1046	VRDESCARDSTATUSRSP pRsp = (VRDESCARDSTATUSRSP )pvData;
1047	UCRREQCTX pCtx = (UCRREQCTX )pvUser;
1048
1049	Assert(pCtx->u32Function == u32Function);
1050
1051	LogFlowFunc(("STATUS\n"));
1052
1053	char *pszReaderName = NULL;
1054	uint32_t cchReaderName = 0;
1055	uint32_t u32CardState = 0;
1056	uint32_t u32Protocol = 0;
1057	uint32_t u32AtrLength = 0;
1058	uint8_t *pbAtr = NULL;
1059
1060	uint32_t rcCard;
1061
1062	if (RT_FAILURE(rcRequest))
1063	{
1064	rcCard = VRDE_SCARD_E_NO_SMARTCARD;
1065	}
1066	else
1067	{
1068	rcCard = pRsp->u32ReturnCode;
1069
1070	if (pRsp->u32ReturnCode == VRDE_SCARD_S_SUCCESS)
1071	{
1072	pszReaderName = pRsp->szReader;
1073	cchReaderName = (uint32_t)strlen(pRsp->szReader) + 1;
1074	u32CardState = pRsp->u32State;
1075	u32Protocol = pRsp->u32Protocol;
1076	u32AtrLength = pRsp->u32AtrLength;
1077	pbAtr = &pRsp->au8Atr[0];
1078	}
1079	}
1080
1081	mpDrv->pICardReaderUp->pfnStatus(mpDrv->pICardReaderUp,
1082	pCtx->pvUser,
1083	rcCard,
1084	pszReaderName,
1085	cchReaderName,
1086	u32CardState,
1087	u32Protocol,
1088	pbAtr,
1089	u32AtrLength);
1090
1091	RTMemFree(pCtx);
1092	} break;
1093
1094	case VRDE_SCARD_FN_TRANSMIT:
1095	{
1096	Assert(cbData == sizeof(VRDESCARDTRANSMITRSP) \|\| RT_FAILURE(rcRequest));
1097	VRDESCARDTRANSMITRSP pRsp = (VRDESCARDTRANSMITRSP )pvData;
1098	UCRREQCTX pCtx = (UCRREQCTX )pvUser;
1099
1100	Assert(pCtx->u32Function == u32Function);
1101
1102	LogFlowFunc(("TRANSMIT\n"));
1103
1104	PDMICARDREADER_IO_REQUEST *pioRecvPci = NULL;
1105	uint8_t *pu8RecvBuffer = NULL;
1106	uint32_t cbRecvBuffer = 0;
1107
1108	uint32_t rcCard;
1109
1110	if (RT_FAILURE(rcRequest))
1111	{
1112	rcCard = VRDE_SCARD_E_NO_SMARTCARD;
1113	}
1114	else
1115	{
1116	rcCard = pRsp->u32ReturnCode;
1117
1118	if (pRsp->u32ReturnCode == VRDE_SCARD_S_SUCCESS)
1119	{
1120	pu8RecvBuffer = pRsp->pu8RecvBuffer;
1121	cbRecvBuffer = pRsp->u32RecvLength;
1122	/** @todo pioRecvPci */
1123	}
1124	}
1125
1126	mpDrv->pICardReaderUp->pfnTransmit(mpDrv->pICardReaderUp,
1127	pCtx->pvUser,
1128	rcCard,
1129	pioRecvPci,
1130	pu8RecvBuffer,
1131	cbRecvBuffer);
1132
1133	RTMemFree(pioRecvPci);
1134
1135	RTMemFree(pCtx);
1136	} break;
1137
1138	case VRDE_SCARD_FN_CONTROL:
1139	{
1140	Assert(cbData == sizeof(VRDESCARDCONTROLRSP) \|\| RT_FAILURE(rcRequest));
1141	VRDESCARDCONTROLRSP pRsp = (VRDESCARDCONTROLRSP )pvData;
1142	UCRREQCTX pCtx = (UCRREQCTX )pvUser;
1143
1144	Assert(pCtx->u32Function == u32Function);
1145
1146	LogFlowFunc(("CONTROL\n"));
1147
1148	uint8_t *pu8OutBuffer = NULL;
1149	uint32_t cbOutBuffer = 0;
1150
1151	uint32_t rcCard;
1152
1153	if (RT_FAILURE(rcRequest))
1154	{
1155	rcCard = VRDE_SCARD_E_NO_SMARTCARD;
1156	}
1157	else
1158	{
1159	rcCard = pRsp->u32ReturnCode;
1160
1161	if (pRsp->u32ReturnCode == VRDE_SCARD_S_SUCCESS)
1162	{
1163	pu8OutBuffer = pRsp->pu8OutBuffer;
1164	cbOutBuffer = pRsp->u32OutBufferSize;
1165	}
1166	}
1167
1168	mpDrv->pICardReaderUp->pfnControl(mpDrv->pICardReaderUp,
1169	pCtx->pvUser,
1170	rcCard,
1171	pCtx->u.Control.u32ControlCode,
1172	pu8OutBuffer,
1173	cbOutBuffer);
1174
1175	RTMemFree(pCtx);
1176	} break;
1177
1178	case VRDE_SCARD_FN_GETATTRIB:
1179	{
1180	Assert(cbData == sizeof(VRDESCARDGETATTRIBRSP) \|\| RT_FAILURE(rcRequest));
1181	VRDESCARDGETATTRIBRSP pRsp = (VRDESCARDGETATTRIBRSP )pvData;
1182	UCRREQCTX pCtx = (UCRREQCTX )pvUser;
1183
1184	Assert(pCtx->u32Function == u32Function);
1185
1186	LogFlowFunc(("GETATTRIB\n"));
1187
1188	uint8_t *pu8Attrib = NULL;
1189	uint32_t cbAttrib = 0;
1190
1191	uint32_t rcCard;
1192
1193	if (RT_FAILURE(rcRequest))
1194	{
1195	rcCard = VRDE_SCARD_E_NO_SMARTCARD;
1196	}
1197	else
1198	{
1199	rcCard = pRsp->u32ReturnCode;
1200
1201	if (pRsp->u32ReturnCode == VRDE_SCARD_S_SUCCESS)
1202	{
1203	pu8Attrib = pRsp->pu8Attr;
1204	cbAttrib = pRsp->u32AttrLength;
1205	}
1206	}
1207
1208	mpDrv->pICardReaderUp->pfnGetAttrib(mpDrv->pICardReaderUp,
1209	pCtx->pvUser,
1210	rcCard,
1211	pCtx->u.GetAttrib.u32AttrId,
1212	pu8Attrib,
1213	cbAttrib);
1214
1215	RTMemFree(pCtx);
1216	} break;
1217
1218	case VRDE_SCARD_FN_SETATTRIB:
1219	{
1220	Assert(cbData == sizeof(VRDESCARDSETATTRIBRSP) \|\| RT_FAILURE(rcRequest));
1221	VRDESCARDSETATTRIBRSP pRsp = (VRDESCARDSETATTRIBRSP )pvData;
1222	UCRREQCTX pCtx = (UCRREQCTX )pvUser;
1223
1224	Assert(pCtx->u32Function == u32Function);
1225
1226	LogFlowFunc(("SETATTRIB\n"));
1227
1228	uint32_t rcCard;
1229
1230	if (RT_FAILURE(rcRequest))
1231	{
1232	rcCard = VRDE_SCARD_E_NO_SMARTCARD;
1233	}
1234	else
1235	{
1236	rcCard = pRsp->u32ReturnCode;
1237	}
1238
1239	mpDrv->pICardReaderUp->pfnSetAttrib(mpDrv->pICardReaderUp,
1240	pCtx->pvUser,
1241	rcCard,
1242	pCtx->u.SetAttrib.u32AttrId);
1243
1244	RTMemFree(pCtx);
1245	} break;
1246
1247	default:
1248	AssertFailed();
1249	rc = VERR_INVALID_PARAMETER;
1250	break;
1251	}
1252
1253	return rc;
1254	}
1255
1256	int UsbCardReader::EstablishContext(struct USBCARDREADER *pDrv)
1257	{
1258	AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
1259
1260	/* The context here is a not a real device context.
1261	* The device can be detached at the moment, for example the VRDP client did not connect yet.
1262	*/
1263
1264	return mpDrv->pICardReaderUp->pfnEstablishContext(mpDrv->pICardReaderUp,
1265	VRDE_SCARD_S_SUCCESS);
1266	}
1267
1268	int UsbCardReader::ReleaseContext(struct USBCARDREADER *pDrv)
1269	{
1270	AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
1271
1272	int rc = VINF_SUCCESS;
1273
1274	if ( !m_pRemote
1275	\|\| !m_pRemote->fContext)
1276	{
1277	/* Do nothing. */
1278	}
1279	else
1280	{
1281	UCRREQCTX pCtx = (UCRREQCTX )RTMemAlloc(sizeof(UCRREQCTX));
1282	if (!pCtx)
1283	{
1284	/* Do nothing. */
1285	}
1286	else
1287	{
1288	pCtx->pRemote = m_pRemote;
1289	pCtx->u32Function = VRDE_SCARD_FN_RELEASECONTEXT;
1290	pCtx->pvUser = NULL;
1291
1292	VRDESCARDRELEASECONTEXTREQ req;
1293	req.Context = m_pRemote->context;
1294
1295	rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_RELEASECONTEXT, &req, sizeof(req));
1296
1297	if (RT_FAILURE(rc))
1298	{
1299	RTMemFree(pCtx);
1300	}
1301	else
1302	{
1303	m_pRemote->fContext = false;
1304	}
1305	}
1306	}
1307
1308	return rc;
1309	}
1310
1311	int UsbCardReader::GetStatusChange(struct USBCARDREADER *pDrv,
1312	void *pvUser,
1313	uint32_t u32Timeout,
1314	PDMICARDREADER_READERSTATE *paReaderStats,
1315	uint32_t cReaderStats)
1316	{
1317	AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
1318
1319	int rc = VINF_SUCCESS;
1320
1321	if ( !m_pRemote
1322	\|\| !m_pRemote->fContext
1323	\|\| !m_pRemote->reader.fAvailable)
1324	{
1325	rc = mpDrv->pICardReaderUp->pfnSetStatusChange(mpDrv->pICardReaderUp,
1326	pvUser,
1327	VRDE_SCARD_E_NO_SMARTCARD,
1328	paReaderStats,
1329	cReaderStats);
1330	}
1331	else
1332	{
1333	UCRREQCTX pCtx = (UCRREQCTX )RTMemAlloc(sizeof(UCRREQCTX));
1334	if (!pCtx)
1335	{
1336	rc = mpDrv->pICardReaderUp->pfnSetStatusChange(mpDrv->pICardReaderUp,
1337	pvUser,
1338	VRDE_SCARD_E_NO_MEMORY,
1339	paReaderStats,
1340	cReaderStats);
1341	}
1342	else
1343	{
1344	pCtx->pRemote = m_pRemote;
1345	pCtx->u32Function = VRDE_SCARD_FN_GETSTATUSCHANGE;
1346	pCtx->pvUser = pvUser;
1347	pCtx->u.GetStatusChange.paReaderStats = paReaderStats;
1348	pCtx->u.GetStatusChange.cReaderStats = cReaderStats;
1349
1350	VRDESCARDGETSTATUSCHANGEREQ req;
1351	req.Context = m_pRemote->context;
1352	req.u32Timeout = u32Timeout;
1353	req.cReaders = 1;
1354	req.aReaderStates[0].pszReader = &m_pRemote->reader.szReaderName[0];
1355	req.aReaderStates[0].u32CurrentState = paReaderStats[0].u32CurrentState;
1356
1357	rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_GETSTATUSCHANGE, &req, sizeof(req));
1358
1359	if (RT_FAILURE(rc))
1360	{
1361	RTMemFree(pCtx);
1362	}
1363	}
1364	}
1365
1366	return rc;
1367	}
1368
1369	int UsbCardReader::Connect(struct USBCARDREADER *pDrv,
1370	void *pvUser,
1371	const char *pszReaderName,
1372	uint32_t u32ShareMode,
1373	uint32_t u32PreferredProtocols)
1374	{
1375	RT_NOREF(pszReaderName);
1376	AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
1377
1378	int rc = VINF_SUCCESS;
1379
1380	if ( !m_pRemote
1381	\|\| !m_pRemote->fContext
1382	\|\| !m_pRemote->reader.fAvailable)
1383	{
1384	rc = mpDrv->pICardReaderUp->pfnConnect(mpDrv->pICardReaderUp,
1385	pvUser,
1386	VRDE_SCARD_E_NO_SMARTCARD,
1387	VRDE_SCARD_PROTOCOL_T0);
1388	}
1389	else
1390	{
1391	UCRREQCTX pCtx = (UCRREQCTX )RTMemAlloc(sizeof(UCRREQCTX));
1392	if (!pCtx)
1393	{
1394	rc = mpDrv->pICardReaderUp->pfnConnect(mpDrv->pICardReaderUp,
1395	pvUser,
1396	VRDE_SCARD_E_NO_MEMORY,
1397	VRDE_SCARD_PROTOCOL_T0);
1398	}
1399	else
1400	{
1401	pCtx->pRemote = m_pRemote;
1402	pCtx->u32Function = VRDE_SCARD_FN_CONNECT;
1403	pCtx->pvUser = pvUser;
1404
1405	VRDESCARDCONNECTREQ req;
1406	req.Context = m_pRemote->context;
1407	req.pszReader = &m_pRemote->reader.szReaderName[0];
1408	req.u32ShareMode = u32ShareMode;
1409	req.u32PreferredProtocols = u32PreferredProtocols;
1410
1411	rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_CONNECT, &req, sizeof(req));
1412
1413	if (RT_FAILURE(rc))
1414	{
1415	RTMemFree(pCtx);
1416	}
1417	}
1418	}
1419
1420	return rc;
1421	}
1422
1423	int UsbCardReader::Disconnect(struct USBCARDREADER *pDrv,
1424	void *pvUser,
1425	uint32_t u32Mode)
1426	{
1427	AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
1428
1429	int rc = VINF_SUCCESS;
1430
1431	if ( !m_pRemote
1432	\|\| !m_pRemote->fContext
1433	\|\| !m_pRemote->reader.fAvailable
1434	\|\| !m_pRemote->reader.fHandle)
1435	{
1436	rc = mpDrv->pICardReaderUp->pfnDisconnect(mpDrv->pICardReaderUp,
1437	pvUser,
1438	VRDE_SCARD_E_NO_SMARTCARD);
1439	}
1440	else
1441	{
1442	UCRREQCTX pCtx = (UCRREQCTX )RTMemAlloc(sizeof(UCRREQCTX));
1443	if (!pCtx)
1444	{
1445	rc = mpDrv->pICardReaderUp->pfnDisconnect(mpDrv->pICardReaderUp,
1446	pvUser,
1447	VRDE_SCARD_E_NO_MEMORY);
1448	}
1449	else
1450	{
1451	pCtx->pRemote = m_pRemote;
1452	pCtx->u32Function = VRDE_SCARD_FN_DISCONNECT;
1453	pCtx->pvUser = pvUser;
1454
1455	VRDESCARDDISCONNECTREQ req;
1456	req.hCard = m_pRemote->reader.hCard;
1457	req.u32Disposition = u32Mode;
1458
1459	rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_DISCONNECT, &req, sizeof(req));
1460
1461	if (RT_FAILURE(rc))
1462	{
1463	RTMemFree(pCtx);
1464	}
1465	else
1466	{
1467	m_pRemote->reader.fHandle = false;
1468	}
1469	}
1470	}
1471
1472	return rc;
1473	}
1474
1475	int UsbCardReader::Status(struct USBCARDREADER *pDrv,
1476	void *pvUser)
1477	{
1478	AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
1479
1480	int rc = VINF_SUCCESS;
1481
1482	if ( !m_pRemote
1483	\|\| !m_pRemote->fContext
1484	\|\| !m_pRemote->reader.fAvailable
1485	\|\| !m_pRemote->reader.fHandle)
1486	{
1487	rc = mpDrv->pICardReaderUp->pfnStatus(mpDrv->pICardReaderUp,
1488	pvUser,
1489	VRDE_SCARD_E_NO_SMARTCARD,
1490	/* pszReaderName */ NULL,
1491	/* cchReaderName */ 0,
1492	/* u32CardState */ 0,
1493	/* u32Protocol */ 0,
1494	/* pu8Atr */ 0,
1495	/* cbAtr */ 0);
1496	}
1497	else
1498	{
1499	UCRREQCTX pCtx = (UCRREQCTX )RTMemAlloc(sizeof(UCRREQCTX));
1500	if (!pCtx)
1501	{
1502	rc = mpDrv->pICardReaderUp->pfnStatus(mpDrv->pICardReaderUp,
1503	pvUser,
1504	VRDE_SCARD_E_NO_MEMORY,
1505	/* pszReaderName */ NULL,
1506	/* cchReaderName */ 0,
1507	/* u32CardState */ 0,
1508	/* u32Protocol */ 0,
1509	/* pu8Atr */ 0,
1510	/* cbAtr */ 0);
1511	}
1512	else
1513	{
1514	pCtx->pRemote = m_pRemote;
1515	pCtx->u32Function = VRDE_SCARD_FN_STATUS;
1516	pCtx->pvUser = pvUser;
1517
1518	VRDESCARDSTATUSREQ req;
1519	req.hCard = m_pRemote->reader.hCard;
1520
1521	rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_STATUS, &req, sizeof(req));
1522
1523	if (RT_FAILURE(rc))
1524	{
1525	RTMemFree(pCtx);
1526	}
1527	}
1528	}
1529
1530	return rc;
1531	}
1532
1533	int UsbCardReader::Transmit(struct USBCARDREADER *pDrv,
1534	void *pvUser,
1535	PDMICARDREADER_IO_REQUEST *pioSendRequest,
1536	uint8_t *pu8SendBuffer,
1537	uint32_t cbSendBuffer,
1538	uint32_t cbRecvBuffer)
1539	{
1540	AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
1541
1542	int rc = VINF_SUCCESS;
1543
1544	UCRREQCTX *pCtx = NULL;
1545	uint32_t rcSCard = VRDE_SCARD_S_SUCCESS;
1546
1547	if ( !m_pRemote
1548	\|\| !m_pRemote->fContext
1549	\|\| !m_pRemote->reader.fAvailable
1550	\|\| !m_pRemote->reader.fHandle)
1551	{
1552	rcSCard = VRDE_SCARD_E_NO_SMARTCARD;
1553	}
1554
1555	if (rcSCard == VRDE_SCARD_S_SUCCESS)
1556	{
1557	if ( !pioSendRequest
1558	\|\| ( pioSendRequest->cbPciLength < 2 * sizeof(uint32_t)
1559	\|\| pioSendRequest->cbPciLength > 2 * sizeof(uint32_t) + VRDE_SCARD_MAX_PCI_DATA)
1560	)
1561	{
1562	AssertFailed();
1563	rcSCard = VRDE_SCARD_E_INVALID_PARAMETER;
1564	}
1565	}
1566
1567	if (rcSCard == VRDE_SCARD_S_SUCCESS)
1568	{
1569	pCtx = (UCRREQCTX *)RTMemAlloc(sizeof(UCRREQCTX));
1570	if (!pCtx)
1571	{
1572	rcSCard = VRDE_SCARD_E_NO_MEMORY;
1573	}
1574	}
1575
1576	if (rcSCard != VRDE_SCARD_S_SUCCESS)
1577	{
1578	Assert(pCtx == NULL);
1579
1580	rc = pDrv->pICardReaderUp->pfnTransmit(pDrv->pICardReaderUp,
1581	pvUser,
1582	rcSCard,
1583	/* pioRecvPci */ NULL,
1584	/* pu8RecvBuffer */ NULL,
1585	/* cbRecvBuffer*/ 0);
1586	}
1587	else
1588	{
1589	pCtx->pRemote = m_pRemote;
1590	pCtx->u32Function = VRDE_SCARD_FN_TRANSMIT;
1591	pCtx->pvUser = pvUser;
1592
1593	VRDESCARDTRANSMITREQ req;
1594	req.hCard = m_pRemote->reader.hCard;
1595
1596	req.ioSendPci.u32Protocol = pioSendRequest->u32Protocol;
1597	req.ioSendPci.u32PciLength = pioSendRequest->cbPciLength < 2 * sizeof(uint32_t)?
1598	(uint32_t)(2 * sizeof(uint32_t)):
1599	pioSendRequest->cbPciLength;
1600	Assert(pioSendRequest->cbPciLength <= VRDE_SCARD_MAX_PCI_DATA + 2 * sizeof(uint32_t));
1601	memcpy(req.ioSendPci.au8PciData,
1602	(uint8_t )pioSendRequest + 2 sizeof(uint32_t),
1603	req.ioSendPci.u32PciLength - 2 * sizeof(uint32_t));
1604
1605	req.u32SendLength = cbSendBuffer;
1606	req.pu8SendBuffer = pu8SendBuffer;
1607	req.u32RecvLength = cbRecvBuffer;
1608
1609	rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_TRANSMIT, &req, sizeof(req));
1610
1611	if (RT_FAILURE(rc))
1612	{
1613	RTMemFree(pCtx);
1614	}
1615	}
1616
1617	return rc;
1618	}
1619
1620	int UsbCardReader::Control(struct USBCARDREADER *pDrv,
1621	void *pvUser,
1622	uint32_t u32ControlCode,
1623	uint8_t *pu8InBuffer,
1624	uint32_t cbInBuffer,
1625	uint32_t cbOutBuffer)
1626	{
1627	AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
1628
1629	int rc = VINF_SUCCESS;
1630
1631	UCRREQCTX *pCtx = NULL;
1632	uint32_t rcSCard = VRDE_SCARD_S_SUCCESS;
1633
1634	if ( !m_pRemote
1635	\|\| !m_pRemote->fContext
1636	\|\| !m_pRemote->reader.fAvailable
1637	\|\| !m_pRemote->reader.fHandle)
1638	{
1639	rcSCard = VRDE_SCARD_E_NO_SMARTCARD;
1640	}
1641
1642	if (rcSCard == VRDE_SCARD_S_SUCCESS)
1643	{
1644	if ( cbInBuffer > _128K
1645	\|\| cbOutBuffer > _128K)
1646	{
1647	AssertFailed();
1648	rcSCard = VRDE_SCARD_E_INVALID_PARAMETER;
1649	}
1650	}
1651
1652	if (rcSCard == VRDE_SCARD_S_SUCCESS)
1653	{
1654	pCtx = (UCRREQCTX *)RTMemAlloc(sizeof(UCRREQCTX));
1655	if (!pCtx)
1656	{
1657	rcSCard = VRDE_SCARD_E_NO_MEMORY;
1658	}
1659	}
1660
1661	if (rcSCard != VRDE_SCARD_S_SUCCESS)
1662	{
1663	Assert(pCtx == NULL);
1664
1665	rc = pDrv->pICardReaderUp->pfnControl(pDrv->pICardReaderUp,
1666	pvUser,
1667	rcSCard,
1668	u32ControlCode,
1669	/* pvOutBuffer */ NULL,
1670	/* cbOutBuffer*/ 0);
1671	}
1672	else
1673	{
1674	pCtx->pRemote = m_pRemote;
1675	pCtx->u32Function = VRDE_SCARD_FN_CONTROL;
1676	pCtx->pvUser = pvUser;
1677	pCtx->u.Control.u32ControlCode = u32ControlCode;
1678
1679	VRDESCARDCONTROLREQ req;
1680	req.hCard = m_pRemote->reader.hCard;
1681	req.u32ControlCode = u32ControlCode;
1682	req.u32InBufferSize = cbInBuffer;
1683	req.pu8InBuffer = pu8InBuffer;
1684	req.u32OutBufferSize = cbOutBuffer;
1685
1686	rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_CONTROL, &req, sizeof(req));
1687
1688	if (RT_FAILURE(rc))
1689	{
1690	RTMemFree(pCtx);
1691	}
1692	}
1693
1694	return rc;
1695	}
1696
1697	int UsbCardReader::GetAttrib(struct USBCARDREADER *pDrv,
1698	void *pvUser,
1699	uint32_t u32AttrId,
1700	uint32_t cbAttrib)
1701	{
1702	AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
1703
1704	int rc = VINF_SUCCESS;
1705
1706	UCRREQCTX *pCtx = NULL;
1707	uint32_t rcSCard = VRDE_SCARD_S_SUCCESS;
1708
1709	if ( !m_pRemote
1710	\|\| !m_pRemote->fContext
1711	\|\| !m_pRemote->reader.fAvailable
1712	\|\| !m_pRemote->reader.fHandle)
1713	{
1714	rcSCard = VRDE_SCARD_E_NO_SMARTCARD;
1715	}
1716
1717	if (rcSCard == VRDE_SCARD_S_SUCCESS)
1718	{
1719	if (cbAttrib > _128K)
1720	{
1721	AssertFailed();
1722	rcSCard = VRDE_SCARD_E_INVALID_PARAMETER;
1723	}
1724	}
1725
1726	if (rcSCard == VRDE_SCARD_S_SUCCESS)
1727	{
1728	pCtx = (UCRREQCTX *)RTMemAlloc(sizeof(UCRREQCTX));
1729	if (!pCtx)
1730	{
1731	rcSCard = VRDE_SCARD_E_NO_MEMORY;
1732	}
1733	}
1734
1735	if (rcSCard != VRDE_SCARD_S_SUCCESS)
1736	{
1737	Assert(pCtx == NULL);
1738
1739	pDrv->pICardReaderUp->pfnGetAttrib(pDrv->pICardReaderUp,
1740	pvUser,
1741	rcSCard,
1742	u32AttrId,
1743	/* pvAttrib */ NULL,
1744	/* cbAttrib */ 0);
1745	}
1746	else
1747	{
1748	pCtx->pRemote = m_pRemote;
1749	pCtx->u32Function = VRDE_SCARD_FN_GETATTRIB;
1750	pCtx->pvUser = pvUser;
1751	pCtx->u.GetAttrib.u32AttrId = u32AttrId;
1752
1753	VRDESCARDGETATTRIBREQ req;
1754	req.hCard = m_pRemote->reader.hCard;
1755	req.u32AttrId = u32AttrId;
1756	req.u32AttrLen = cbAttrib;
1757
1758	rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_GETATTRIB, &req, sizeof(req));
1759
1760	if (RT_FAILURE(rc))
1761	{
1762	RTMemFree(pCtx);
1763	}
1764	}
1765
1766	return rc;
1767	}
1768
1769	int UsbCardReader::SetAttrib(struct USBCARDREADER *pDrv,
1770	void *pvUser,
1771	uint32_t u32AttrId,
1772	uint8_t *pu8Attrib,
1773	uint32_t cbAttrib)
1774	{
1775	AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
1776
1777	int rc = VINF_SUCCESS;
1778
1779	UCRREQCTX *pCtx = NULL;
1780	uint32_t rcSCard = VRDE_SCARD_S_SUCCESS;
1781
1782	if ( !m_pRemote
1783	\|\| !m_pRemote->fContext
1784	\|\| !m_pRemote->reader.fAvailable
1785	\|\| !m_pRemote->reader.fHandle)
1786	{
1787	rcSCard = VRDE_SCARD_E_NO_SMARTCARD;
1788	}
1789
1790	if (rcSCard == VRDE_SCARD_S_SUCCESS)
1791	{
1792	if (cbAttrib > _128K)
1793	{
1794	AssertFailed();
1795	rcSCard = VRDE_SCARD_E_INVALID_PARAMETER;
1796	}
1797	}
1798
1799	if (rcSCard == VRDE_SCARD_S_SUCCESS)
1800	{
1801	pCtx = (UCRREQCTX *)RTMemAlloc(sizeof(UCRREQCTX));
1802	if (!pCtx)
1803	{
1804	rcSCard = VRDE_SCARD_E_NO_MEMORY;
1805	}
1806	}
1807
1808	if (rcSCard != VRDE_SCARD_S_SUCCESS)
1809	{
1810	Assert(pCtx == NULL);
1811
1812	pDrv->pICardReaderUp->pfnSetAttrib(pDrv->pICardReaderUp,
1813	pvUser,
1814	rcSCard,
1815	u32AttrId);
1816	}
1817	else
1818	{
1819	pCtx->pRemote = m_pRemote;
1820	pCtx->u32Function = VRDE_SCARD_FN_SETATTRIB;
1821	pCtx->pvUser = pvUser;
1822	pCtx->u.SetAttrib.u32AttrId = u32AttrId;
1823
1824	VRDESCARDSETATTRIBREQ req;
1825	req.hCard = m_pRemote->reader.hCard;
1826	req.u32AttrId = u32AttrId;
1827	req.u32AttrLen = cbAttrib;
1828	req.pu8Attr = pu8Attrib;
1829
1830	rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_SETATTRIB, &req, sizeof(req));
1831
1832	if (RT_FAILURE(rc))
1833	{
1834	RTMemFree(pCtx);
1835	}
1836	}
1837
1838	return rc;
1839	}
1840
1841
1842	/*
1843	* PDMDRVINS
1844	*/
1845
1846	/* static / DECLCALLBACK(void ) UsbCardReader::drvQueryInterface(PPDMIBASE pInterface, const char *pszIID)
1847	{
1848	LogFlowFunc(("pInterface:%p, pszIID:%s\n", pInterface, pszIID));
1849	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
1850	PUSBCARDREADER pThis = PDMINS_2_DATA(pDrvIns, PUSBCARDREADER);
1851
1852	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
1853	PDMIBASE_RETURN_INTERFACE(pszIID, PDMICARDREADERDOWN, &pThis->ICardReaderDown);
1854	return NULL;
1855	}
1856
1857	/* static */ DECLCALLBACK(void) UsbCardReader::drvDestruct(PPDMDRVINS pDrvIns)
1858	{
1859	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
1860	LogFlowFunc(("iInstance/%d\n",pDrvIns->iInstance));
1861	PUSBCARDREADER pThis = PDMINS_2_DATA(pDrvIns, PUSBCARDREADER);
1862
1863	/** @todo The driver is destroyed before the device.
1864	* So device calls ReleaseContext when there is no more driver.
1865	* Notify the device here so it can do cleanup or
1866	* do a cleanup now in the driver.
1867	*/
1868	if (pThis->hReqQCardReaderCmd != NIL_RTREQQUEUE)
1869	{
1870	int rc = RTReqQueueDestroy(pThis->hReqQCardReaderCmd);
1871	AssertRC(rc);
1872	pThis->hReqQCardReaderCmd = NIL_RTREQQUEUE;
1873	}
1874
1875	pThis->pUsbCardReader->mpDrv = NULL;
1876	pThis->pUsbCardReader = NULL;
1877	LogFlowFuncLeave();
1878	}
1879
1880	/* static */ DECLCALLBACK(int) UsbCardReader::drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
1881	{
1882	RT_NOREF(fFlags, pCfg);
1883	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
1884	LogFlowFunc(("iInstance/%d, pCfg:%p, fFlags:%x\n", pDrvIns->iInstance, pCfg, fFlags));
1885	PUSBCARDREADER pThis = PDMINS_2_DATA(pDrvIns, PUSBCARDREADER);
1886
1887	pThis->hReqQCardReaderCmd = NIL_RTREQQUEUE;
1888
1889	PDMDRV_VALIDATE_CONFIG_RETURN(pDrvIns, "", "");
1890	AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
1891	("Configuration error: Not possible to attach anything to this driver!\n"),
1892	VERR_PDM_DRVINS_NO_ATTACH);
1893
1894	com::Guid uuid(USBCARDREADER_OID);
1895	pThis->pUsbCardReader = (UsbCardReader *)PDMDrvHlpQueryGenericUserObject(pDrvIns, uuid.raw());
1896	AssertMsgReturn(RT_VALID_PTR(pThis->pUsbCardReader), ("Configuration error: No/bad USB card reader object value!\n"), VERR_NOT_FOUND);
1897
1898	pThis->pUsbCardReader->mpDrv = pThis;
1899	pThis->pDrvIns = pDrvIns;
1900
1901	pDrvIns->IBase.pfnQueryInterface = UsbCardReader::drvQueryInterface;
1902
1903	pThis->ICardReaderDown.pfnEstablishContext = drvCardReaderDownEstablishContext;
1904	pThis->ICardReaderDown.pfnReleaseContext = drvCardReaderDownReleaseContext;
1905	pThis->ICardReaderDown.pfnConnect = drvCardReaderDownConnect;
1906	pThis->ICardReaderDown.pfnDisconnect = drvCardReaderDownDisconnect;
1907	pThis->ICardReaderDown.pfnStatus = drvCardReaderDownStatus;
1908	pThis->ICardReaderDown.pfnGetStatusChange = drvCardReaderDownGetStatusChange;
1909	pThis->ICardReaderDown.pfnBeginTransaction = drvCardReaderDownBeginTransaction;
1910	pThis->ICardReaderDown.pfnEndTransaction = drvCardReaderDownEndTransaction;
1911	pThis->ICardReaderDown.pfnTransmit = drvCardReaderDownTransmit;
1912	pThis->ICardReaderDown.pfnGetAttr = drvCardReaderDownGetAttr;
1913	pThis->ICardReaderDown.pfnSetAttr = drvCardReaderDownSetAttr;
1914	pThis->ICardReaderDown.pfnControl = drvCardReaderDownControl;
1915
1916	pThis->pICardReaderUp = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMICARDREADERUP);
1917	AssertReturn(pThis->pICardReaderUp, VERR_PDM_MISSING_INTERFACE);
1918
1919	/* Command Thread Synchronization primitives */
1920	int rc = RTReqQueueCreate(&pThis->hReqQCardReaderCmd);
1921	AssertLogRelRCReturn(rc, rc);
1922
1923	rc = PDMDrvHlpThreadCreate(pDrvIns,
1924	&pThis->pThrCardReaderCmd,
1925	pThis,
1926	drvCardReaderThreadCmd /* worker routine */,
1927	drvCardReaderThreadCmdWakeup /* wakeup routine */,
1928	128 * _1K, RTTHREADTYPE_IO, "UCRCMD");
1929	if (RT_FAILURE(rc))
1930	{
1931	RTReqQueueDestroy(pThis->hReqQCardReaderCmd);
1932	pThis->hReqQCardReaderCmd = NIL_RTREQQUEUE;
1933	}
1934
1935	LogFlowFunc(("LEAVE: %Rrc\n", rc));
1936	return rc;
1937	}
1938
1939	/* static */ const PDMDRVREG UsbCardReader::DrvReg =
1940	{
1941	/* u32Version */
1942	PDM_DRVREG_VERSION,
1943	/* szName[32] */
1944	"UsbCardReader",
1945	/* szRCMod[32] */
1946	"",
1947	/* szR0Mod[32] */
1948	"",
1949	/* pszDescription */
1950	"Main Driver communicating with VRDE",
1951	/* fFlags */
1952	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1953	/* fClass */
1954	PDM_DRVREG_CLASS_USB,
1955	/* cMaxInstances */
1956	1,
1957	/* cbInstance */
1958	sizeof(USBCARDREADER),
1959	/* pfnConstruct */
1960	UsbCardReader::drvConstruct,
1961	/* pfnDestruct */
1962	UsbCardReader::drvDestruct,
1963	/* pfnRelocate */
1964	NULL,
1965	/* pfnIOCtl */
1966	NULL,
1967	/* pfnPowerOn */
1968	NULL,
1969	/* pfnReset */
1970	NULL,
1971	/* pfnSuspend */
1972	NULL,
1973	/* pfnResume */
1974	NULL,
1975	/* pfnAttach */
1976	NULL,
1977	/* pfnDetach */
1978	NULL,
1979	/* pfnPowerOff */
1980	NULL,
1981	/* pfnSoftReset */
1982	NULL,
1983	/* u32VersionEnd */
1984	PDM_DRVREG_VERSION
1985	};
1986	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/src-client/UsbCardReader.cpp@ 98273

Download in other formats: