VirtualBox

Changeset 98276 in vbox


Ignore:
Timestamp:
Jan 24, 2023 11:34:55 AM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
155479
Message:

Main/UsbCardReader.cpp: rc -> hrc/vrc. bugref:10223

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vmm/pdmcardreaderinfs.h

    r98103 r98276  
    8383    DECLR3CALLBACKMEMBER(int, pfnEndTransaction,(PPDMICARDREADERDOWN pInterface, void *pvUser, uint32_t u32Disposition));
    8484    DECLR3CALLBACKMEMBER(int, pfnTransmit,(PPDMICARDREADERDOWN pInterface, void *pvUser,
    85                                            const PDMICARDREADER_IO_REQUEST *pioSendRequest,
     85                                           const PDMICARDREADER_IO_REQUEST *pIoSendRequest,
    8686                                           const uint8_t *pu8SendBuffer, uint32_t cbSendBuffer, uint32_t cbRecvBuffer));
    8787    /**

  • trunk/include/VBox/vmm/pdmifs.h

    r98103 r98276  
    22882288    DECLR3CALLBACKMEMBER(int, pfnDeviceConstructComplete, (PPDMIPCIRAWCONNECTOR pInterface, const char *pcszName,
    22892289                                                           uint32_t uHostPciAddress, uint32_t uGuestPciAddress,
    2290                                                            int rc));
     2290                                                           int vrc));
    22912291
    22922292} PDMIPCIRAWCONNECTOR;

  • trunk/src/VBox/Main/src-client/UsbCardReader.cpp

    r98103 r98276  
    7676                                                       uint32_t cReaderStats)
    7777{
    78     LogFlowFunc(("ENTER: pvUser:%p, u32Timeout:%d\n",
    79                  pvUser, u32Timeout));
     78    LogFlowFunc(("ENTER: pvUser:%p, u32Timeout:%d\n", pvUser, u32Timeout));
    8079
    8180    UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
    8281    if (!pUsbCardReader)
    83     {
    8482        pThis->pICardReaderUp->pfnSetStatusChange(pThis->pICardReaderUp,
    8583                                                  pvUser, VRDE_SCARD_E_NO_SMARTCARD,
    8684                                                  paReaderStats, cReaderStats);
    87     }
    8885    else
    89     {
    90         pUsbCardReader->GetStatusChange(pThis, pvUser, u32Timeout,
    91                                         paReaderStats, cReaderStats);
    92     }
     86        pUsbCardReader->GetStatusChange(pThis, pvUser, u32Timeout, paReaderStats, cReaderStats);
    9387
    9488    LogFlowFuncLeave();
    … …  
    10296    UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
    10397    if (!pUsbCardReader)
    104     {
    105         pThis->pICardReaderUp->pfnEstablishContext(pThis->pICardReaderUp,
    106                                                    VRDE_SCARD_E_NO_SMARTCARD);
    107     }
     98        pThis->pICardReaderUp->pfnEstablishContext(pThis->pICardReaderUp, VRDE_SCARD_E_NO_SMARTCARD);
    10899    else
    109     {
    110100        pUsbCardReader->EstablishContext(pThis);
    111     }
    112101
    113102    LogFlowFuncLeave();
    114103}
    115104
    116 static DECLCALLBACK(void) drvCardReaderCmdReleaseContext(PUSBCARDREADER pThis,
    117                                                          void *pvUser)
    118 {
    119     LogFlowFunc(("ENTER: pvUser:%p\n",
    120                  pvUser));
     105static DECLCALLBACK(void) drvCardReaderCmdReleaseContext(PUSBCARDREADER pThis, void *pvUser)
     106{
     107    LogFlowFunc(("ENTER: pvUser:%p\n", pvUser));
    121108    NOREF(pvUser);
    122109
    … …  
    127114    }
    128115    else
    129     {
    130116        pUsbCardReader->ReleaseContext(pThis);
    131     }
    132117
    133118    LogFlowFuncLeave();
    134119}
    135120
    136 static DECLCALLBACK(void) drvCardReaderCmdStatus(PUSBCARDREADER pThis,
    137                                                  void *pvUser)
    138 {
    139     LogFlowFunc(("ENTER: pvUser:%p\n",
    140                  pvUser));
     121static DECLCALLBACK(void) drvCardReaderCmdStatus(PUSBCARDREADER pThis, void *pvUser)
     122{
     123    LogFlowFunc(("ENTER: pvUser:%p\n", pvUser));
    141124
    142125    UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
    … …  
    154137    }
    155138    else
    156     {
    157139        pUsbCardReader->Status(pThis, pvUser);
    158     }
    159140
    160141    LogFlowFuncLeave();
    … …  
    172153    UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
    173154    if (!pUsbCardReader)
    174     {
    175155        pThis->pICardReaderUp->pfnConnect(pThis->pICardReaderUp,
    176156                                          pvUser,
    177157                                          VRDE_SCARD_E_NO_SMARTCARD,
    178158                                          0);
    179     }
    180159    else
    181     {
    182         pUsbCardReader->Connect(pThis, pvUser, pcszCardReaderName,
    183                                 u32ShareMode, u32PreferredProtocols);
    184     }
     160        pUsbCardReader->Connect(pThis, pvUser, pcszCardReaderName, u32ShareMode, u32PreferredProtocols);
    185161
    186162    LogFlowFuncLeave();
    … …  
    191167                                                     uint32_t u32Disposition)
    192168{
    193     LogFlowFunc(("ENTER: pvUser:%p, u32Disposition:%RX32\n",
    194                  pvUser, u32Disposition));
     169    LogFlowFunc(("ENTER: pvUser:%p, u32Disposition:%RX32\n", pvUser, u32Disposition));
    195170
    196171    UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
    197172    if (!pUsbCardReader)
    198     {
    199         pThis->pICardReaderUp->pfnDisconnect(pThis->pICardReaderUp,
    200                                              pvUser,
    201                                              VRDE_SCARD_E_NO_SMARTCARD);
    202     }
     173        pThis->pICardReaderUp->pfnDisconnect(pThis->pICardReaderUp, pvUser, VRDE_SCARD_E_NO_SMARTCARD);
    203174    else
    204     {
    205175        pUsbCardReader->Disconnect(pThis, pvUser, u32Disposition);
    206     }
    207176
    208177    LogFlowFuncLeave();
    … …  
    211180static DECLCALLBACK(void) drvCardReaderCmdTransmit(PUSBCARDREADER pThis,
    212181                                                   void *pvUser,
    213                                                    PDMICARDREADER_IO_REQUEST *pioSendRequest,
    214                                                    uint8_t *pu8SendBuffer,
     182                                                   PDMICARDREADER_IO_REQUEST *pIoSendRequest,
     183                                                   uint8_t *pbSendBuffer,
    215184                                                   uint32_t cbSendBuffer,
    216185                                                   uint32_t cbRecvBuffer)
    217186{
    218     LogFlowFunc(("ENTER: pvUser:%p, pioSendRequest:%p, pu8SendBuffer:%p, cbSendBuffer:%d, cbRecvBuffer:%d\n",
    219                  pvUser, pioSendRequest, pu8SendBuffer, cbSendBuffer, cbRecvBuffer));
     187    LogFlowFunc(("ENTER: pvUser:%p, pIoSendRequest:%p, pbSendBuffer:%p, cbSendBuffer:%d, cbRecvBuffer:%d\n",
     188                 pvUser, pIoSendRequest, pbSendBuffer, cbSendBuffer, cbRecvBuffer));
    220189
    221190    UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
    222191    if (!pUsbCardReader)
    223     {
    224192        pThis->pICardReaderUp->pfnTransmit(pThis->pICardReaderUp,
    225193                                           pvUser,
    … …  
    228196                                           /* pu8RecvBuffer */ NULL,
    229197                                           /* cbRecvBuffer*/ 0);
    230     }
    231198    else
    232     {
    233         pUsbCardReader->Transmit(pThis, pvUser, pioSendRequest,
    234                                  pu8SendBuffer, cbSendBuffer, cbRecvBuffer);
    235     }
     199        pUsbCardReader->Transmit(pThis, pvUser, pIoSendRequest, pbSendBuffer, cbSendBuffer, cbRecvBuffer);
    236200
    237201    /* Clean up buffers allocated by driver */
    238     RTMemFree(pioSendRequest);
    239     RTMemFree(pu8SendBuffer);
     202    RTMemFree(pIoSendRequest);
     203    RTMemFree(pbSendBuffer);
    240204
    241205    LogFlowFuncLeave();
    … …  
    252216    UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
    253217    if (!pUsbCardReader)
    254     {
    255218        pThis->pICardReaderUp->pfnGetAttrib(pThis->pICardReaderUp,
    256219                                            pvUser,
    … …  
    259222                                            /* pvAttrib */ NULL,
    260223                                            /* cbAttrib */ 0);
    261     }
    262224    else
    263     {
    264225        pUsbCardReader->GetAttrib(pThis, pvUser, u32AttrId, cbAttrib);
    265     }
    266226
    267227    LogFlowFuncLeave();
    … …  
    279239    UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
    280240    if (!pUsbCardReader)
    281     {
    282         pThis->pICardReaderUp->pfnSetAttrib(pThis->pICardReaderUp,
    283                                             pvUser,
    284                                             VRDE_SCARD_E_NO_SMARTCARD,
    285                                             u32AttrId);
    286     }
     241        pThis->pICardReaderUp->pfnSetAttrib(pThis->pICardReaderUp, pvUser, VRDE_SCARD_E_NO_SMARTCARD, u32AttrId);
    287242    else
    288     {
    289243        pUsbCardReader->SetAttrib(pThis, pvUser, u32AttrId, (uint8_t *)pvAttrib, cbAttrib);
    290     }
    291244
    292245    /* Clean up buffers allocated by driver */
    … …  
    308261    UsbCardReader *pUsbCardReader = pThis->pUsbCardReader;
    309262    if (!pUsbCardReader)
    310     {
    311263        pThis->pICardReaderUp->pfnControl(pThis->pICardReaderUp,
    312264                                          pvUser,
    … …  
    315267                                          /* pvOutBuffer */ NULL,
    316268                                          /* cbOutBuffer */ 0);
    317     }
    318269    else
    319     {
    320         pUsbCardReader->Control(pThis, pvUser, u32ControlCode,
    321                                 (uint8_t *)pvInBuffer, cbInBuffer, cbOutBuffer);
    322     }
     270        pUsbCardReader->Control(pThis, pvUser, u32ControlCode, (uint8_t *)pvInBuffer, cbInBuffer, cbOutBuffer);
    323271
    324272    /* Clean up buffers allocated by driver */
    … …  
    333281 */
    334282
     283/** @implement_interface_method{PDMICARDREADERDOWN,pfnConnect} */
    335284static DECLCALLBACK(int) drvCardReaderDownConnect(PPDMICARDREADERDOWN pInterface,
    336285                                                  void *pvUser,
    … …  
    343292                 pcszCardReaderName, pvUser, u32ShareMode, u32PreferredProtocols));
    344293    PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
    345     int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
    346                               (PFNRT)drvCardReaderCmdConnect, 5,
    347                               pThis, pvUser, pcszCardReaderName, u32ShareMode, u32PreferredProtocols);
    348     AssertRC(rc);
    349     LogFlowFunc(("LEAVE: %Rrc\n", rc));
    350     return rc;
    351 }
    352 
     294    int vrc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
     295                               (PFNRT)drvCardReaderCmdConnect, 5,
     296                               pThis, pvUser, pcszCardReaderName, u32ShareMode, u32PreferredProtocols);
     297    AssertRC(vrc);
     298    LogFlowFunc(("LEAVE: %Rrc\n", vrc));
     299    return vrc;
     300}
     301
     302/** @implement_interface_method{PDMICARDREADERDOWN,pfnDisconnect} */
    353303static DECLCALLBACK(int) drvCardReaderDownDisconnect(PPDMICARDREADERDOWN pInterface,
    354304                                                     void *pvUser,
    … …  
    359309                 pvUser, u32Disposition));
    360310    PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
    361     int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
    362                               (PFNRT)drvCardReaderCmdDisconnect, 3,
    363                               pThis, pvUser, u32Disposition);
    364     AssertRC(rc);
    365     LogFlowFunc(("LEAVE: %Rrc\n", rc));
    366     return rc;
    367 }
    368 
     311    int vrc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
     312                               (PFNRT)drvCardReaderCmdDisconnect, 3,
     313                               pThis, pvUser, u32Disposition);
     314    AssertRC(vrc);
     315    LogFlowFunc(("LEAVE: %Rrc\n", vrc));
     316    return vrc;
     317}
     318
     319/** @implement_interface_method{PDMICARDREADERDOWN,pfnEstablishContext} */
    369320static DECLCALLBACK(int) drvCardReaderDownEstablishContext(PPDMICARDREADERDOWN pInterface)
    370321{
    … …  
    372323    LogFlowFunc(("ENTER:\n"));
    373324    PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
    374     int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
    375                               (PFNRT)drvCardReaderCmdEstablishContext, 1,
    376                               pThis);
    377     AssertRC(rc);
    378     LogFlowFunc(("LEAVE: %Rrc\n", rc));
    379     return rc;
    380 }
    381 
     325    int vrc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
     326                               (PFNRT)drvCardReaderCmdEstablishContext, 1,
     327                               pThis);
     328    AssertRC(vrc);
     329    LogFlowFunc(("LEAVE: %Rrc\n", vrc));
     330    return vrc;
     331}
     332
     333/** @implement_interface_method{PDMICARDREADERDOWN,pfnReleaseContext} */
    382334static DECLCALLBACK(int) drvCardReaderDownReleaseContext(PPDMICARDREADERDOWN pInterface,
    383335                                                         void *pvUser)
    384336{
    385337    AssertPtrReturn(pInterface, VERR_INVALID_PARAMETER);
    386     LogFlowFunc(("ENTER: pvUser:%p\n",
    387                  pvUser));
     338    LogFlowFunc(("ENTER: pvUser:%p\n", pvUser));
    388339    PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
     340
    389341    /** @todo Device calls this when the driver already destroyed. */
    390342    if (pThis->hReqQCardReaderCmd == NIL_RTREQQUEUE)
    … …  
    394346    }
    395347
    396     int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
    397                               (PFNRT)drvCardReaderCmdReleaseContext, 2,
    398                               pThis, pvUser);
    399     AssertRC(rc);
    400     LogFlowFunc(("LEAVE: %Rrc\n", rc));
    401     return rc;
    402 }
    403 
     348    int vrc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
     349                               (PFNRT)drvCardReaderCmdReleaseContext, 2,
     350                               pThis, pvUser);
     351    AssertRC(vrc);
     352    LogFlowFunc(("LEAVE: %Rrc\n", vrc));
     353    return vrc;
     354}
     355
     356/** @implement_interface_method{PDMICARDREADERDOWN,pfnStatus} */
    404357static DECLCALLBACK(int) drvCardReaderDownStatus(PPDMICARDREADERDOWN pInterface,
    405358                                                 void *pvUser,
    … …  
    413366    NOREF(cbAtrLen);
    414367    PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
    415     int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
    416                              (PFNRT)drvCardReaderCmdStatus, 2,
    417                              pThis, pvUser);
    418     AssertRC(rc);
    419     LogFlowFunc(("LEAVE: %Rrc\n", rc));
    420     return rc;
    421 }
    422 
     368    int vrc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
     369                              (PFNRT)drvCardReaderCmdStatus, 2,
     370                              pThis, pvUser);
     371    AssertRC(vrc);
     372    LogFlowFunc(("LEAVE: %Rrc\n", vrc));
     373    return vrc;
     374}
     375
     376/** @implement_interface_method{PDMICARDREADERDOWN,pfnStatusChange} */
    423377static DECLCALLBACK(int) drvCardReaderDownGetStatusChange(PPDMICARDREADERDOWN pInterface,
    424378                                                          void *pvUser,
    … …  
    431385                 pvUser, u32Timeout, cReaderStats));
    432386    PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
    433     int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
    434                               (PFNRT)drvCardReaderCmdStatusChange, 5,
    435                               pThis, pvUser, u32Timeout, paReaderStats, cReaderStats);
    436     AssertRC(rc);
    437     LogFlowFunc(("LEAVE: %Rrc\n", rc));
    438     return rc;
    439 }
    440 
     387    int vrc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
     388                               (PFNRT)drvCardReaderCmdStatusChange, 5,
     389                               pThis, pvUser, u32Timeout, paReaderStats, cReaderStats);
     390    AssertRC(vrc);
     391    LogFlowFunc(("LEAVE: %Rrc\n", vrc));
     392    return vrc;
     393}
     394
     395/** @implement_interface_method{PDMICARDREADERDOWN,pfnBeginTransaction} */
    441396static DECLCALLBACK(int) drvCardReaderDownBeginTransaction(PPDMICARDREADERDOWN pInterface,
    442397                                                           void *pvUser)
    … …  
    447402                 pvUser));
    448403    PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown); NOREF(pThis);
    449     int rc = VERR_NOT_SUPPORTED;
    450     AssertRC(rc);
    451     LogFlowFunc(("LEAVE: %Rrc\n", rc));
    452     return rc;
    453 }
    454 
     404    int vrc = VERR_NOT_SUPPORTED;
     405    AssertRC(vrc);
     406    LogFlowFunc(("LEAVE: %Rrc\n", vrc));
     407    return vrc;
     408}
     409
     410/** @implement_interface_method{PDMICARDREADERDOWN,pfnEndTransaction} */
    455411static DECLCALLBACK(int) drvCardReaderDownEndTransaction(PPDMICARDREADERDOWN pInterface,
    456412                                                         void *pvUser,
    … …  
    462418                 pvUser, u32Disposition));
    463419    PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown); NOREF(pThis);
    464     int rc = VERR_NOT_SUPPORTED;
    465     AssertRC(rc);
    466     LogFlowFunc(("LEAVE: %Rrc\n", rc));
    467     return rc;
    468 }
    469 
     420    int vrc = VERR_NOT_SUPPORTED;
     421    AssertRC(vrc);
     422    LogFlowFunc(("LEAVE: %Rrc\n", vrc));
     423    return vrc;
     424}
     425
     426/** @implement_interface_method{PDMICARDREADERDOWN,pfnTransmit} */
    470427static DECLCALLBACK(int) drvCardReaderDownTransmit(PPDMICARDREADERDOWN pInterface,
    471428                                                   void *pvUser,
    472                                                    const PDMICARDREADER_IO_REQUEST *pioSendRequest,
    473                                                    const uint8_t *pu8SendBuffer,
     429                                                   const PDMICARDREADER_IO_REQUEST *pIoSendRequest,
     430                                                   const uint8_t *pbSendBuffer,
    474431                                                   uint32_t cbSendBuffer,
    475432                                                   uint32_t cbRecvBuffer)
    476433{
    477434    AssertPtrReturn(pInterface, VERR_INVALID_PARAMETER);
    478     LogFlowFunc(("ENTER: pvUser:%p, pioSendRequest:%p, pu8SendBuffer:%p, cbSendBuffer:%d, cbRecvBuffer:%d\n",
    479                  pvUser, pioSendRequest, pu8SendBuffer, cbSendBuffer, cbRecvBuffer));
     435    LogFlowFunc(("ENTER: pvUser:%p, pIoSendRequest:%p, pbSendBuffer:%p, cbSendBuffer:%d, cbRecvBuffer:%d\n",
     436                 pvUser, pIoSendRequest, pbSendBuffer, cbSendBuffer, cbRecvBuffer));
    480437    PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
    481     uint8_t *pu8SendBufferCopy = NULL;
    482     if (   pu8SendBuffer
     438    uint8_t *pbSendBufferCopy = NULL;
     439    if (   pbSendBuffer
    483440        && cbSendBuffer)
    484441    {
    485         pu8SendBufferCopy = (uint8_t *)RTMemDup(pu8SendBuffer, cbSendBuffer);
    486         if (!pu8SendBufferCopy)
    487         {
     442        pbSendBufferCopy = (uint8_t *)RTMemDup(pbSendBuffer, cbSendBuffer);
     443        if (!pbSendBufferCopy)
     444            return VERR_NO_MEMORY;
     445    }
     446    PDMICARDREADER_IO_REQUEST *pIoSendRequestCopy = NULL;
     447    if (pIoSendRequest)
     448    {
     449        pIoSendRequestCopy = (PDMICARDREADER_IO_REQUEST *)RTMemDup(pIoSendRequest, pIoSendRequest->cbPciLength);
     450        if (!pIoSendRequestCopy)
     451        {
     452            RTMemFree(pbSendBufferCopy);
    488453            return VERR_NO_MEMORY;
    489454        }
    490455    }
    491     PDMICARDREADER_IO_REQUEST *pioSendRequestCopy = NULL;
    492     if (pioSendRequest)
    493     {
    494         pioSendRequestCopy = (PDMICARDREADER_IO_REQUEST *)RTMemDup(pioSendRequest, pioSendRequest->cbPciLength);
    495         if (!pioSendRequestCopy)
    496         {
    497             RTMemFree(pu8SendBufferCopy);
    498             return VERR_NO_MEMORY;
    499         }
    500     }
    501     int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0,RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
    502                               (PFNRT)drvCardReaderCmdTransmit, 6,
    503                               pThis, pvUser, pioSendRequestCopy, pu8SendBufferCopy, cbSendBuffer, cbRecvBuffer);
    504     AssertRC(rc);
    505     LogFlowFunc(("LEAVE: %Rrc\n", rc));
    506     return rc;
    507 }
    508 
     456    int vrc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0,RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
     457                               (PFNRT)drvCardReaderCmdTransmit, 6,
     458                               pThis, pvUser, pIoSendRequestCopy, pbSendBufferCopy, cbSendBuffer, cbRecvBuffer);
     459    AssertRC(vrc);
     460    LogFlowFunc(("LEAVE: %Rrc\n", vrc));
     461    return vrc;
     462}
     463
     464/** @implement_interface_method{PDMICARDREADERDOWN,pfnGetAttr} */
    509465static DECLCALLBACK(int) drvCardReaderDownGetAttr(PPDMICARDREADERDOWN pInterface,
    510466                                                  void *pvUser,
    … …  
    516472                 pvUser, u32AttribId, cbAttrib));
    517473    PUSBCARDREADER pThis = RT_FROM_MEMBER(pInterface, USBCARDREADER, ICardReaderDown);
    518     int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
    519                               (PFNRT)drvCardReaderCmdGetAttr, 4,
    520                               pThis, pvUser, u32AttribId, cbAttrib);
    521     AssertRC(rc);
    522     LogFlowFunc(("LEAVE: %Rrc\n", rc));
    523     return rc;
    524 }
    525 
     474    int vrc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
     475                               (PFNRT)drvCardReaderCmdGetAttr, 4,
     476                               pThis, pvUser, u32AttribId, cbAttrib);
     477    AssertRC(vrc);
     478    LogFlowFunc(("LEAVE: %Rrc\n", vrc));
     479    return vrc;
     480}
     481
     482/** @implement_interface_method{PDMICARDREADERDOWN,pfnSetAttr} */
    526483static DECLCALLBACK(int) drvCardReaderDownSetAttr(PPDMICARDREADERDOWN pInterface,
    527484                                                  void *pvUser,
    … …  
    541498        AssertPtrReturn(pvAttribCopy, VERR_NO_MEMORY);
    542499    }
    543     int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
    544                               (PFNRT)drvCardReaderCmdSetAttr, 5,
    545                               pThis, pvUser, u32AttribId, pvAttribCopy, cbAttrib);
    546     AssertRC(rc);
    547     LogFlowFunc(("LEAVE: %Rrc\n", rc));
    548     return rc;
    549 }
    550 
     500    int vrc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
     501                               (PFNRT)drvCardReaderCmdSetAttr, 5,
     502                               pThis, pvUser, u32AttribId, pvAttribCopy, cbAttrib);
     503    AssertRC(vrc);
     504    LogFlowFunc(("LEAVE: %Rrc\n", vrc));
     505    return vrc;
     506}
     507
     508/** @implement_interface_method{PDMICARDREADERDOWN,pfnControl} */
    551509static DECLCALLBACK(int) drvCardReaderDownControl(PPDMICARDREADERDOWN pInterface,
    552510                                                  void *pvUser,
    … …  
    567525        AssertReturn(pvInBufferCopy, VERR_NO_MEMORY);
    568526    }
    569     int rc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
    570                               (PFNRT)drvCardReaderCmdControl, 6,
    571                               pThis, pvUser, u32ControlCode, pvInBufferCopy, cbInBuffer, cbOutBuffer);
    572     AssertRC(rc);
    573     LogFlowFunc(("LEAVE: %Rrc\n", rc));
    574     return rc;
     527    int vrc = RTReqQueueCallEx(pThis->hReqQCardReaderCmd, NULL, 0, RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
     528                               (PFNRT)drvCardReaderCmdControl, 6,
     529                               pThis, pvUser, u32ControlCode, pvInBufferCopy, cbInBuffer, cbOutBuffer);
     530    AssertRC(vrc);
     531    LogFlowFunc(("LEAVE: %Rrc\n", vrc));
     532    return vrc;
    575533}
    576534
    … …  
    581539static DECLCALLBACK(int) drvCardReaderThreadCmd(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
    582540{
    583     int rc = VINF_SUCCESS;
    584541    PUSBCARDREADER pThis = PDMINS_2_DATA(pDrvIns, PUSBCARDREADER);
    585542
    … …  
    592549    }
    593550
     551    int vrc = VINF_SUCCESS;
    594552    while (pThread->enmState == PDMTHREADSTATE_RUNNING)
    595553    {
    596         rc = RTReqQueueProcess(pThis->hReqQCardReaderCmd, RT_INDEFINITE_WAIT);
    597 
    598         AssertMsg(rc == VWRN_STATE_CHANGED,
    599                   ("Left RTReqProcess and error code is not VWRN_STATE_CHANGED rc=%Rrc\n",
    600                    rc));
    601     }
    602 
    603     LogFlowFunc(("LEAVE: %Rrc\n", rc));
    604     return rc;
     554        vrc = RTReqQueueProcess(pThis->hReqQCardReaderCmd, RT_INDEFINITE_WAIT);
     555
     556        AssertMsg(vrc == VWRN_STATE_CHANGED, ("Left RTReqProcess and error code is not VWRN_STATE_CHANGED vrc=%Rrc\n", vrc));
     557    }
     558
     559    LogFlowFunc(("LEAVE: %Rrc\n", vrc));
     560    return vrc;
    605561}
    606562
    … …  
    621577
    622578    PRTREQ pReq;
    623     int rc = RTReqQueueCall(pThis->hReqQCardReaderCmd, &pReq, 10000, (PFNRT)drvCardReaderWakeupFunc, 1, pThis);
    624     AssertMsgRC(rc, ("Inserting request into queue failed rc=%Rrc\n", rc));
    625 
    626     if (RT_SUCCESS(rc))
     579    int vrc = RTReqQueueCall(pThis->hReqQCardReaderCmd, &pReq, 10000, (PFNRT)drvCardReaderWakeupFunc, 1, pThis);
     580    AssertMsgRC(vrc, ("Inserting request into queue failed vrc=%Rrc\n", vrc));
     581
     582    if (RT_SUCCESS(vrc))
    627583        RTReqRelease(pReq);
    628584    /** @todo handle VERR_TIMEOUT */
    629585
    630     return rc;
     586    return vrc;
    631587}
    632588
    … …  
    708664int UsbCardReader::vrdeSCardRequest(void *pvUser, uint32_t u32Function, const void *pvData, uint32_t cbData)
    709665{
    710     int rc = mParent->i_consoleVRDPServer()->SCardRequest(pvUser, u32Function, pvData, cbData);
    711     LogFlowFunc(("%d %Rrc\n", u32Function, rc));
    712     return rc;
     666    int vrc = mParent->i_consoleVRDPServer()->SCardRequest(pvUser, u32Function, pvData, cbData);
     667    LogFlowFunc(("%d %Rrc\n", u32Function, vrc));
     668    return vrc;
    713669}
    714670
    … …  
    716672{
    717673    RT_NOREF(cbData);
    718     int rc = VINF_SUCCESS;
     674    int vrc = VINF_SUCCESS;
    719675
    720676    switch (u32Id)
    … …  
    727683            LogFlowFunc(("[%d,%d]\n", p->u32ClientId, p->u32DeviceId));
    728684
    729             /* Add this remote instance, which allow access to card readers attached to the client, to the list.
    730              * @todo currently only one device is allowed.
    731              */
     685            /* Add this remote instance, which allow access to card readers attached to the client, to the list. */
     686            /** @todo currently only one device is allowed. */
    732687            if (m_pRemote)
    733688            {
    734689                AssertFailed();
    735                 rc = VERR_NOT_SUPPORTED;
     690                vrc = VERR_NOT_SUPPORTED;
    736691                break;
    737692            }
    … …  
    739694            if (pRemote == NULL)
    740695            {
    741                 rc = VERR_NO_MEMORY;
     696                vrc = VERR_NO_MEMORY;
    742697                break;
    743698            }
    … …  
    754709            req.u32DeviceId = m_pRemote->u32DeviceId;
    755710
    756             rc = vrdeSCardRequest(m_pRemote, VRDE_SCARD_FN_ESTABLISHCONTEXT, &req, sizeof(req));
     711            vrc = vrdeSCardRequest(m_pRemote, VRDE_SCARD_FN_ESTABLISHCONTEXT, &req, sizeof(req));
    757712
    758713            LogFlowFunc(("sent ESTABLISHCONTEXT\n"));
    … …  
    770725
    771726        default:
    772             rc = VERR_INVALID_PARAMETER;
     727            vrc = VERR_INVALID_PARAMETER;
    773728            AssertFailed();
    774729            break;
    775730    }
    776731
    777     return rc;
     732    return vrc;
    778733}
    779734
    … …  
    781736{
    782737    RT_NOREF(cbData);
    783     int rc = VINF_SUCCESS;
    784 
    785     LogFlowFunc(("%Rrc %p %u %p %u\n",
    786                  rcRequest, pvUser, u32Function, pvData, cbData));
     738    int vrc = VINF_SUCCESS;
     739
     740    LogFlowFunc(("%Rrc %p %u %p %u\n", rcRequest, pvUser, u32Function, pvData, cbData));
    787741
    788742    switch (u32Function)
    … …  
    808762                req.Context = pRemote->context;
    809763
    810                 rc = vrdeSCardRequest(pRemote, VRDE_SCARD_FN_LISTREADERS, &req, sizeof(req));
     764                vrc = vrdeSCardRequest(pRemote, VRDE_SCARD_FN_LISTREADERS, &req, sizeof(req));
    811765            }
    812766        } break;
    … …  
    12471201        default:
    12481202            AssertFailed();
    1249             rc = VERR_INVALID_PARAMETER;
     1203            vrc = VERR_INVALID_PARAMETER;
    12501204            break;
    12511205    }
    12521206
    1253     return rc;
     1207    return vrc;
    12541208}
    12551209
    … …  
    12701224    AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
    12711225
    1272     int rc = VINF_SUCCESS;
     1226    int vrc = VINF_SUCCESS;
    12731227
    12741228    if (   !m_pRemote
    … …  
    12931247            req.Context = m_pRemote->context;
    12941248
    1295             rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_RELEASECONTEXT, &req, sizeof(req));
    1296 
    1297             if (RT_FAILURE(rc))
    1298             {
     1249            vrc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_RELEASECONTEXT, &req, sizeof(req));
     1250            if (RT_FAILURE(vrc))
    12991251                RTMemFree(pCtx);
    1300             }
    13011252            else
    1302             {
    13031253                m_pRemote->fContext = false;
    1304             }
    13051254        }
    13061255    }
    13071256
    1308     return rc;
     1257    return vrc;
    13091258}
    13101259
    … …  
    13171266    AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
    13181267
    1319     int rc = VINF_SUCCESS;
    1320 
     1268    int vrc;
    13211269    if (   !m_pRemote
    13221270        || !m_pRemote->fContext
    13231271        || !m_pRemote->reader.fAvailable)
    1324     {
    1325         rc = mpDrv->pICardReaderUp->pfnSetStatusChange(mpDrv->pICardReaderUp,
    1326                                                        pvUser,
    1327                                                        VRDE_SCARD_E_NO_SMARTCARD,
    1328                                                        paReaderStats,
    1329                                                        cReaderStats);
    1330     }
     1272        vrc = mpDrv->pICardReaderUp->pfnSetStatusChange(mpDrv->pICardReaderUp,
     1273                                                        pvUser,
     1274                                                        VRDE_SCARD_E_NO_SMARTCARD,
     1275                                                        paReaderStats,
     1276                                                        cReaderStats);
    13311277    else
    13321278    {
    13331279        UCRREQCTX *pCtx = (UCRREQCTX *)RTMemAlloc(sizeof(UCRREQCTX));
    13341280        if (!pCtx)
    1335         {
    1336             rc = mpDrv->pICardReaderUp->pfnSetStatusChange(mpDrv->pICardReaderUp,
    1337                                                            pvUser,
    1338                                                            VRDE_SCARD_E_NO_MEMORY,
    1339                                                            paReaderStats,
    1340                                                            cReaderStats);
    1341         }
     1281            vrc = mpDrv->pICardReaderUp->pfnSetStatusChange(mpDrv->pICardReaderUp,
     1282                                                            pvUser,
     1283                                                            VRDE_SCARD_E_NO_MEMORY,
     1284                                                            paReaderStats,
     1285                                                            cReaderStats);
    13421286        else
    13431287        {
    … …  
    13551299            req.aReaderStates[0].u32CurrentState = paReaderStats[0].u32CurrentState;
    13561300
    1357             rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_GETSTATUSCHANGE, &req, sizeof(req));
    1358 
    1359             if (RT_FAILURE(rc))
    1360             {
     1301            vrc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_GETSTATUSCHANGE, &req, sizeof(req));
     1302            if (RT_FAILURE(vrc))
    13611303                RTMemFree(pCtx);
    1362             }
    13631304        }
    13641305    }
    13651306
    1366     return rc;
     1307    return vrc;
    13671308}
    13681309
    … …  
    13761317    AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
    13771318
    1378     int rc = VINF_SUCCESS;
    1379 
     1319    int vrc;
    13801320    if (   !m_pRemote
    13811321        || !m_pRemote->fContext
    13821322        || !m_pRemote->reader.fAvailable)
    1383     {
    1384         rc = mpDrv->pICardReaderUp->pfnConnect(mpDrv->pICardReaderUp,
    1385                                                pvUser,
    1386                                                VRDE_SCARD_E_NO_SMARTCARD,
    1387                                                VRDE_SCARD_PROTOCOL_T0);
    1388     }
     1323        vrc = mpDrv->pICardReaderUp->pfnConnect(mpDrv->pICardReaderUp,
     1324                                                pvUser,
     1325                                                VRDE_SCARD_E_NO_SMARTCARD,
     1326                                                VRDE_SCARD_PROTOCOL_T0);
    13891327    else
    13901328    {
    13911329        UCRREQCTX *pCtx = (UCRREQCTX *)RTMemAlloc(sizeof(UCRREQCTX));
    13921330        if (!pCtx)
    1393         {
    1394             rc = mpDrv->pICardReaderUp->pfnConnect(mpDrv->pICardReaderUp,
    1395                                                    pvUser,
    1396                                                    VRDE_SCARD_E_NO_MEMORY,
    1397                                                    VRDE_SCARD_PROTOCOL_T0);
    1398         }
     1331            vrc = mpDrv->pICardReaderUp->pfnConnect(mpDrv->pICardReaderUp,
     1332                                                    pvUser,
     1333                                                    VRDE_SCARD_E_NO_MEMORY,
     1334                                                    VRDE_SCARD_PROTOCOL_T0);
    13991335        else
    14001336        {
    … …  
    14091345            req.u32PreferredProtocols = u32PreferredProtocols;
    14101346
    1411             rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_CONNECT, &req, sizeof(req));
    1412 
    1413             if (RT_FAILURE(rc))
    1414             {
     1347            vrc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_CONNECT, &req, sizeof(req));
     1348            if (RT_FAILURE(vrc))
    14151349                RTMemFree(pCtx);
    1416             }
    14171350        }
    14181351    }
    14191352
    1420     return rc;
     1353    return vrc;
    14211354}
    14221355
    … …  
    14271360    AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
    14281361
    1429     int rc = VINF_SUCCESS;
    1430 
     1362    int vrc;
    14311363    if (   !m_pRemote
    14321364        || !m_pRemote->fContext
    14331365        || !m_pRemote->reader.fAvailable
    14341366        || !m_pRemote->reader.fHandle)
    1435     {
    1436         rc = mpDrv->pICardReaderUp->pfnDisconnect(mpDrv->pICardReaderUp,
    1437                                                   pvUser,
    1438                                                   VRDE_SCARD_E_NO_SMARTCARD);
    1439     }
     1367        vrc = mpDrv->pICardReaderUp->pfnDisconnect(mpDrv->pICardReaderUp,
     1368                                                   pvUser,
     1369                                                   VRDE_SCARD_E_NO_SMARTCARD);
    14401370    else
    14411371    {
    14421372        UCRREQCTX *pCtx = (UCRREQCTX *)RTMemAlloc(sizeof(UCRREQCTX));
    14431373        if (!pCtx)
    1444         {
    1445             rc = mpDrv->pICardReaderUp->pfnDisconnect(mpDrv->pICardReaderUp,
    1446                                                       pvUser,
    1447                                                       VRDE_SCARD_E_NO_MEMORY);
    1448         }
     1374            vrc = mpDrv->pICardReaderUp->pfnDisconnect(mpDrv->pICardReaderUp,
     1375                                                       pvUser,
     1376                                                       VRDE_SCARD_E_NO_MEMORY);
    14491377        else
    14501378        {
    … …  
    14571385            req.u32Disposition = u32Mode;
    14581386
    1459             rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_DISCONNECT, &req, sizeof(req));
    1460 
    1461             if (RT_FAILURE(rc))
    1462             {
     1387            vrc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_DISCONNECT, &req, sizeof(req));
     1388            if (RT_FAILURE(vrc))
    14631389                RTMemFree(pCtx);
    1464             }
    14651390            else
    1466             {
    14671391                m_pRemote->reader.fHandle = false;
    1468             }
    14691392        }
    14701393    }
    14711394
    1472     return rc;
     1395    return vrc;
    14731396}
    14741397
    … …  
    14781401    AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
    14791402
    1480     int rc = VINF_SUCCESS;
    1481 
     1403    int vrc;
    14821404    if (   !m_pRemote
    14831405        || !m_pRemote->fContext
    14841406        || !m_pRemote->reader.fAvailable
    14851407        || !m_pRemote->reader.fHandle)
    1486     {
    1487         rc = mpDrv->pICardReaderUp->pfnStatus(mpDrv->pICardReaderUp,
    1488                                               pvUser,
    1489                                               VRDE_SCARD_E_NO_SMARTCARD,
    1490                                               /* pszReaderName */ NULL,
    1491                                               /* cchReaderName */ 0,
    1492                                               /* u32CardState */ 0,
    1493                                               /* u32Protocol */ 0,
    1494                                               /* pu8Atr */ 0,
    1495                                               /* cbAtr */ 0);
    1496     }
     1408        vrc = mpDrv->pICardReaderUp->pfnStatus(mpDrv->pICardReaderUp,
     1409                                               pvUser,
     1410                                               VRDE_SCARD_E_NO_SMARTCARD,
     1411                                               /* pszReaderName */ NULL,
     1412                                               /* cchReaderName */ 0,
     1413                                               /* u32CardState */ 0,
     1414                                               /* u32Protocol */ 0,
     1415                                               /* pu8Atr */ 0,
     1416                                               /* cbAtr */ 0);
    14971417    else
    14981418    {
    14991419        UCRREQCTX *pCtx = (UCRREQCTX *)RTMemAlloc(sizeof(UCRREQCTX));
    15001420        if (!pCtx)
    1501         {
    1502             rc = mpDrv->pICardReaderUp->pfnStatus(mpDrv->pICardReaderUp,
    1503                                                   pvUser,
    1504                                                   VRDE_SCARD_E_NO_MEMORY,
    1505                                                   /* pszReaderName */ NULL,
    1506                                                   /* cchReaderName */ 0,
    1507                                                   /* u32CardState */ 0,
    1508                                                   /* u32Protocol */ 0,
    1509                                                   /* pu8Atr */ 0,
    1510                                                   /* cbAtr */ 0);
    1511         }
     1421            vrc = mpDrv->pICardReaderUp->pfnStatus(mpDrv->pICardReaderUp,
     1422                                                   pvUser,
     1423                                                   VRDE_SCARD_E_NO_MEMORY,
     1424                                                   /* pszReaderName */ NULL,
     1425                                                   /* cchReaderName */ 0,
     1426                                                   /* u32CardState */ 0,
     1427                                                   /* u32Protocol */ 0,
     1428                                                   /* pu8Atr */ 0,
     1429                                                   /* cbAtr */ 0);
    15121430        else
    15131431        {
    … …  
    15191437            req.hCard = m_pRemote->reader.hCard;
    15201438
    1521             rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_STATUS, &req, sizeof(req));
    1522 
    1523             if (RT_FAILURE(rc))
    1524             {
     1439            vrc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_STATUS, &req, sizeof(req));
     1440            if (RT_FAILURE(vrc))
    15251441                RTMemFree(pCtx);
    1526             }
    15271442        }
    15281443    }
    15291444
    1530     return rc;
     1445    return vrc;
    15311446}
    15321447
    15331448int UsbCardReader::Transmit(struct USBCARDREADER *pDrv,
    15341449                            void *pvUser,
    1535                             PDMICARDREADER_IO_REQUEST *pioSendRequest,
    1536                             uint8_t *pu8SendBuffer,
     1450                            PDMICARDREADER_IO_REQUEST *pIoSendRequest,
     1451                            uint8_t *pbSendBuffer,
    15371452                            uint32_t cbSendBuffer,
    15381453                            uint32_t cbRecvBuffer)
    … …  
    15401455    AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
    15411456
    1542     int rc = VINF_SUCCESS;
     1457    int vrc = VINF_SUCCESS;
    15431458
    15441459    UCRREQCTX *pCtx = NULL;
    … …  
    15551470    if (rcSCard == VRDE_SCARD_S_SUCCESS)
    15561471    {
    1557         if (   !pioSendRequest
    1558             || (   pioSendRequest->cbPciLength < 2 *  sizeof(uint32_t)
    1559                 || pioSendRequest->cbPciLength > 2 *  sizeof(uint32_t) + VRDE_SCARD_MAX_PCI_DATA)
     1472        if (   !pIoSendRequest
     1473            || (   pIoSendRequest->cbPciLength < 2 *  sizeof(uint32_t)
     1474                || pIoSendRequest->cbPciLength > 2 *  sizeof(uint32_t) + VRDE_SCARD_MAX_PCI_DATA)
    15601475           )
    15611476        {
    … …  
    15781493        Assert(pCtx == NULL);
    15791494
    1580         rc = pDrv->pICardReaderUp->pfnTransmit(pDrv->pICardReaderUp,
    1581                                                pvUser,
    1582                                                rcSCard,
    1583                                                /* pioRecvPci */ NULL,
    1584                                                /* pu8RecvBuffer */ NULL,
    1585                                                /* cbRecvBuffer*/ 0);
     1495        vrc = pDrv->pICardReaderUp->pfnTransmit(pDrv->pICardReaderUp,
     1496                                                pvUser,
     1497                                                rcSCard,
     1498                                                /* pioRecvPci */ NULL,
     1499                                                /* pu8RecvBuffer */ NULL,
     1500                                                /* cbRecvBuffer*/ 0);
    15861501    }
    15871502    else
    … …  
    15941509        req.hCard = m_pRemote->reader.hCard;
    15951510
    1596         req.ioSendPci.u32Protocol = pioSendRequest->u32Protocol;
    1597         req.ioSendPci.u32PciLength = pioSendRequest->cbPciLength < 2 * sizeof(uint32_t)?
     1511        req.ioSendPci.u32Protocol = pIoSendRequest->u32Protocol;
     1512        req.ioSendPci.u32PciLength = pIoSendRequest->cbPciLength < 2 * sizeof(uint32_t)?
    15981513                                         (uint32_t)(2 * sizeof(uint32_t)):
    1599                                          pioSendRequest->cbPciLength;
    1600         Assert(pioSendRequest->cbPciLength <= VRDE_SCARD_MAX_PCI_DATA + 2 * sizeof(uint32_t));
     1514                                         pIoSendRequest->cbPciLength;
     1515        Assert(pIoSendRequest->cbPciLength <= VRDE_SCARD_MAX_PCI_DATA + 2 * sizeof(uint32_t));
    16011516        memcpy(req.ioSendPci.au8PciData,
    1602                (uint8_t *)pioSendRequest + 2 * sizeof(uint32_t),
     1517               (uint8_t *)pIoSendRequest + 2 * sizeof(uint32_t),
    16031518               req.ioSendPci.u32PciLength - 2 * sizeof(uint32_t));
    16041519
    16051520        req.u32SendLength = cbSendBuffer;
    1606         req.pu8SendBuffer = pu8SendBuffer;
     1521        req.pu8SendBuffer = pbSendBuffer;
    16071522        req.u32RecvLength = cbRecvBuffer;
    16081523
    1609         rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_TRANSMIT, &req, sizeof(req));
    1610 
    1611         if (RT_FAILURE(rc))
    1612         {
     1524        vrc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_TRANSMIT, &req, sizeof(req));
     1525        if (RT_FAILURE(vrc))
    16131526            RTMemFree(pCtx);
    1614         }
    1615     }
    1616 
    1617     return rc;
     1527    }
     1528
     1529    return vrc;
    16181530}
    16191531
    … …  
    16271539    AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
    16281540
    1629     int rc = VINF_SUCCESS;
     1541    int vrc = VINF_SUCCESS;
    16301542
    16311543    UCRREQCTX *pCtx = NULL;
    … …  
    16631575        Assert(pCtx == NULL);
    16641576
    1665         rc = pDrv->pICardReaderUp->pfnControl(pDrv->pICardReaderUp,
    1666                                               pvUser,
    1667                                               rcSCard,
    1668                                               u32ControlCode,
    1669                                               /* pvOutBuffer */ NULL,
    1670                                               /* cbOutBuffer*/ 0);
     1577        vrc = pDrv->pICardReaderUp->pfnControl(pDrv->pICardReaderUp,
     1578                                               pvUser,
     1579                                               rcSCard,
     1580                                               u32ControlCode,
     1581                                               /* pvOutBuffer */ NULL,
     1582                                               /* cbOutBuffer*/ 0);
    16711583    }
    16721584    else
    … …  
    16841596        req.u32OutBufferSize = cbOutBuffer;
    16851597
    1686         rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_CONTROL, &req, sizeof(req));
    1687 
    1688         if (RT_FAILURE(rc))
    1689         {
     1598        vrc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_CONTROL, &req, sizeof(req));
     1599        if (RT_FAILURE(vrc))
    16901600            RTMemFree(pCtx);
    1691         }
    1692     }
    1693 
    1694     return rc;
     1601    }
     1602
     1603    return vrc;
    16951604}
    16961605
    … …  
    17021611    AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
    17031612
    1704     int rc = VINF_SUCCESS;
     1613    int vrc = VINF_SUCCESS;
    17051614
    17061615    UCRREQCTX *pCtx = NULL;
    … …  
    17561665        req.u32AttrLen = cbAttrib;
    17571666
    1758         rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_GETATTRIB, &req, sizeof(req));
    1759 
    1760         if (RT_FAILURE(rc))
    1761         {
     1667        vrc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_GETATTRIB, &req, sizeof(req));
     1668        if (RT_FAILURE(vrc))
    17621669            RTMemFree(pCtx);
    1763         }
    1764     }
    1765 
    1766     return rc;
     1670    }
     1671
     1672    return vrc;
    17671673}
    17681674
    … …  
    17751681    AssertReturn(pDrv == mpDrv, VERR_NOT_SUPPORTED);
    17761682
    1777     int rc = VINF_SUCCESS;
     1683    int vrc = VINF_SUCCESS;
    17781684
    17791685    UCRREQCTX *pCtx = NULL;
    … …  
    18281734        req.pu8Attr = pu8Attrib;
    18291735
    1830         rc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_SETATTRIB, &req, sizeof(req));
    1831 
    1832         if (RT_FAILURE(rc))
    1833         {
     1736        vrc = vrdeSCardRequest(pCtx, VRDE_SCARD_FN_SETATTRIB, &req, sizeof(req));
     1737        if (RT_FAILURE(vrc))
    18341738            RTMemFree(pCtx);
    1835         }
    1836     }
    1837 
    1838     return rc;
     1739    }
     1740
     1741    return vrc;
    18391742}
    18401743
    … …  
    18681771    if (pThis->hReqQCardReaderCmd != NIL_RTREQQUEUE)
    18691772    {
    1870         int rc = RTReqQueueDestroy(pThis->hReqQCardReaderCmd);
    1871         AssertRC(rc);
     1773        int vrc = RTReqQueueDestroy(pThis->hReqQCardReaderCmd);
     1774        AssertRC(vrc);
    18721775        pThis->hReqQCardReaderCmd = NIL_RTREQQUEUE;
    18731776    }
    … …  
    19181821
    19191822    /* Command Thread Synchronization primitives */
    1920     int rc = RTReqQueueCreate(&pThis->hReqQCardReaderCmd);
    1921     AssertLogRelRCReturn(rc, rc);
    1922 
    1923     rc = PDMDrvHlpThreadCreate(pDrvIns,
    1924                                &pThis->pThrCardReaderCmd,
    1925                                pThis,
    1926                                drvCardReaderThreadCmd /* worker routine */,
    1927                                drvCardReaderThreadCmdWakeup /* wakeup routine */,
    1928                                128 * _1K, RTTHREADTYPE_IO, "UCRCMD");
    1929     if (RT_FAILURE(rc))
     1823    int vrc = RTReqQueueCreate(&pThis->hReqQCardReaderCmd);
     1824    AssertLogRelRCReturn(vrc, vrc);
     1825
     1826    vrc = PDMDrvHlpThreadCreate(pDrvIns,
     1827                                &pThis->pThrCardReaderCmd,
     1828                                pThis,
     1829                                drvCardReaderThreadCmd /* worker routine */,
     1830                                drvCardReaderThreadCmdWakeup /* wakeup routine */,
     1831                                128 * _1K, RTTHREADTYPE_IO, "UCRCMD");
     1832    if (RT_FAILURE(vrc))
    19301833    {
    19311834        RTReqQueueDestroy(pThis->hReqQCardReaderCmd);
    … …  
    19331836    }
    19341837
    1935     LogFlowFunc(("LEAVE: %Rrc\n", rc));
    1936     return rc;
     1838    LogFlowFunc(("LEAVE: %Rrc\n", vrc));
     1839    return vrc;
    19371840}
    19381841
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette