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