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