← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/pcsc-lite/intrepid

« back to all changes in this revision

Viewing changes to src/winscard_clnt.c

  • Committer: Bazaar Package Importer
  • Author(s): Ludovic Rousseau
  • Date: 2007-05-23 18:49:36 UTC
  • mfrom: (1.2.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20070523184936-0vda6bhhfvcsrpej
Tags: 1.4.2-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/winscard_clnt.c
6
6
 *  Damien Sauveron <damien.sauveron@labri.fr>
7
7
 *  Ludovic Rousseau <ludovic.rousseau@free.fr>
8
8
 *
9
 
 * $Id: winscard_clnt.c 2527 2007-05-15 20:53:49Z rousseau $
 
9
 * $Id: winscard_clnt.c 2542 2007-05-23 08:15:36Z rousseau $
10
10
 */
11
11
 
12
12
/**
25
25
#include <unistd.h>
26
26
#include <sys/un.h>
27
27
#include <errno.h>
 
28
#include <stddef.h>
28
29
 
29
30
#include "misc.h"
30
31
#include "pcscd.h"
230
231
static LONG SCardGetSetAttrib(SCARDHANDLE hCard, int command, DWORD dwAttrId,
231
232
        LPBYTE pbAttr, LPDWORD pcbAttrLen);
232
233
 
233
 
LONG SCardCheckDaemonAvailability(void);
234
 
 
235
234
void DESTRUCTOR SCardUnload(void);
236
235
 
237
236
/*
483
482
         */
484
483
        scEstablishStruct.dwScope = dwScope;
485
484
        scEstablishStruct.phContext = 0;
486
 
        scEstablishStruct.rv = 0;
 
485
        scEstablishStruct.rv = SCARD_S_SUCCESS;
487
486
 
488
487
        rv = WrapSHMWrite(SCARD_ESTABLISH_CONTEXT, dwClientID,
489
488
                sizeof(scEstablishStruct), PCSCLITE_MCLIENT_ATTEMPTS,
555
554
        SYS_MutexLock(psContextMap[dwContextIndex].mMutex);
556
555
 
557
556
        scReleaseStruct.hContext = hContext;
558
 
        scReleaseStruct.rv = 0;
 
557
        scReleaseStruct.rv = SCARD_S_SUCCESS;
559
558
 
560
559
        rv = WrapSHMWrite(SCARD_RELEASE_CONTEXT, psContextMap[dwContextIndex].dwClientID,
561
560
                          sizeof(scReleaseStruct),
717
716
        scConnectStruct.hContext = hContext;
718
717
        scConnectStruct.dwShareMode = dwShareMode;
719
718
        scConnectStruct.dwPreferredProtocols = dwPreferredProtocols;
720
 
        scConnectStruct.phCard = *phCard;
721
 
        scConnectStruct.pdwActiveProtocol = *pdwActiveProtocol;
 
719
        scConnectStruct.phCard = 0;
 
720
        scConnectStruct.pdwActiveProtocol = 0;
 
721
        scConnectStruct.rv = SCARD_S_SUCCESS;
722
722
 
723
723
        rv = WrapSHMWrite(SCARD_CONNECT, psContextMap[dwContextIndex].dwClientID,
724
724
                sizeof(scConnectStruct),
900
900
                scReconnectStruct.dwPreferredProtocols = dwPreferredProtocols;
901
901
                scReconnectStruct.dwInitialization = dwInitialization;
902
902
                scReconnectStruct.pdwActiveProtocol = *pdwActiveProtocol;
 
903
                scReconnectStruct.rv = SCARD_S_SUCCESS;
903
904
 
904
905
                rv = WrapSHMWrite(SCARD_RECONNECT, psContextMap[dwContextIndex].dwClientID,
905
906
                        sizeof(scReconnectStruct),
996
997
 
997
998
        scDisconnectStruct.hCard = hCard;
998
999
        scDisconnectStruct.dwDisposition = dwDisposition;
 
1000
        scDisconnectStruct.rv = SCARD_S_SUCCESS;
999
1001
 
1000
1002
        rv = WrapSHMWrite(SCARD_DISCONNECT, psContextMap[dwContextIndex].dwClientID,
1001
1003
                sizeof(scDisconnectStruct),
1102
1104
        }
1103
1105
 
1104
1106
        scBeginStruct.hCard = hCard;
 
1107
        scBeginStruct.rv = SCARD_S_SUCCESS;
1105
1108
 
1106
1109
        /*
1107
1110
         * Query the server every so often until the sharing violation ends
1237
1240
 
1238
1241
        scEndStruct.hCard = hCard;
1239
1242
        scEndStruct.dwDisposition = dwDisposition;
 
1243
        scEndStruct.rv = SCARD_S_SUCCESS;
1240
1244
 
1241
1245
        rv = WrapSHMWrite(SCARD_END_TRANSACTION, psContextMap[dwContextIndex].dwClientID,
1242
1246
                sizeof(scEndStruct),
2250
2254
                scControlStructExtended->dwControlCode = dwControlCode;
2251
2255
                scControlStructExtended->cbSendLength = cbSendLength;
2252
2256
                scControlStructExtended->cbRecvLength = cbRecvLength;
2253
 
                scControlStructExtended->size = sizeof(*scControlStructExtended) + cbSendLength;
 
2257
                scControlStructExtended->pdwBytesReturned = 0;
 
2258
                scControlStructExtended->rv = SCARD_S_SUCCESS;
 
2259
                /* The size of data to send is the size of
 
2260
                 * struct control_struct_extended WITHOUT the data[] field
 
2261
                 * plus the effective data[] size
 
2262
                 */
 
2263
                scControlStructExtended->size = sizeof(*scControlStructExtended)
 
2264
                        - (sizeof(control_struct_extended) - offsetof(control_struct_extended, data))
 
2265
                        + cbSendLength;
2254
2266
                memcpy(scControlStructExtended->data, pbSendBuffer, cbSendLength);
2255
2267
 
2256
2268
                rv = WrapSHMWrite(SCARD_CONTROL_EXTENDED,
2560
2572
        scGetSetStruct.dwAttrId = dwAttrId;
2561
2573
        scGetSetStruct.cbAttrLen = *pcbAttrLen;
2562
2574
        scGetSetStruct.rv = SCARD_E_NO_SERVICE;
 
2575
        memset(scGetSetStruct.pbAttr, 0, sizeof(scGetSetStruct.pbAttr));
2563
2576
        if (SCARD_SET_ATTRIB == command)
2564
2577
                memcpy(scGetSetStruct.pbAttr, pbAttr, *pcbAttrLen);
2565
2578
 
2726
2739
                scTransmitStructExtended->hCard = hCard;
2727
2740
                scTransmitStructExtended->cbSendLength = cbSendLength;
2728
2741
                scTransmitStructExtended->pcbRecvLength = *pcbRecvLength;
2729
 
                scTransmitStructExtended->size = sizeof(*scTransmitStructExtended) + cbSendLength;
 
2742
                /* The size of data to send is the size of
 
2743
                 * struct control_struct_extended WITHOUT the data[] field
 
2744
                 * plus the effective data[] size
 
2745
                 */
 
2746
                scTransmitStructExtended->size = sizeof(*scTransmitStructExtended)
 
2747
                        - (sizeof(transmit_struct_extended) - offsetof(transmit_struct_extended, data))
 
2748
                        + cbSendLength;
2730
2749
                memcpy(&scTransmitStructExtended->pioSendPci, pioSendPci,
2731
2750
                        sizeof(SCARD_IO_REQUEST));
2732
2751
                memcpy(scTransmitStructExtended->data, pbSendBuffer, cbSendLength);
 
2752
                scTransmitStructExtended->rv = SCARD_S_SUCCESS;
2733
2753
 
2734
2754
                if (pioRecvPci)
2735
2755
                {
2737
2757
                                sizeof(SCARD_IO_REQUEST));
2738
2758
                }
2739
2759
                else
 
2760
                {
2740
2761
                        scTransmitStructExtended->pioRecvPci.dwProtocol = SCARD_PROTOCOL_ANY;
 
2762
                        scTransmitStructExtended->pioRecvPci.cbPciLength = sizeof(SCARD_IO_REQUEST);
 
2763
                }
2741
2764
 
2742
2765
                rv = WrapSHMWrite(SCARD_TRANSMIT_EXTENDED,
2743
2766
                        psContextMap[dwContextIndex].dwClientID,
2810
2833
                memcpy(&scTransmitStruct.pioSendPci, pioSendPci,
2811
2834
                        sizeof(SCARD_IO_REQUEST));
2812
2835
                memcpy(scTransmitStruct.pbSendBuffer, pbSendBuffer, cbSendLength);
 
2836
                memset(scTransmitStruct.pbSendBuffer+cbSendLength, 0, sizeof(scTransmitStruct.pbSendBuffer)-cbSendLength);
 
2837
                memset(scTransmitStruct.pbRecvBuffer, 0, sizeof(scTransmitStruct.pbRecvBuffer));
 
2838
                scTransmitStruct.rv = SCARD_S_SUCCESS;
2813
2839
 
2814
 
                if (pioRecvPci)
2815
 
                {
2816
 
                        memcpy(&scTransmitStruct.pioRecvPci, pioRecvPci,
2817
 
                                sizeof(SCARD_IO_REQUEST));
2818
 
                }
2819
 
                else
2820
 
                        scTransmitStruct.pioRecvPci.dwProtocol = SCARD_PROTOCOL_ANY;
 
2840
                scTransmitStruct.pioRecvPci.dwProtocol = SCARD_PROTOCOL_ANY;
 
2841
                scTransmitStruct.pioRecvPci.cbPciLength = sizeof(scTransmitStruct.pioRecvPci);
2821
2842
 
2822
2843
                rv = WrapSHMWrite(SCARD_TRANSMIT,
2823
2844
                        psContextMap[dwContextIndex].dwClientID, sizeof(scTransmitStruct),