/[openpgpmdrv]/trunk/OpenPGPminidriver/PublicDataOperations.c
ViewVC logotype

Diff of /trunk/OpenPGPminidriver/PublicDataOperations.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1 by vletoux, Tue Feb 23 19:18:59 2010 UTC revision 9 by vletoux, Mon Mar 15 09:47:30 2010 UTC
# Line 23  Line 23 
23  #include "SmartCard.h"  #include "SmartCard.h"
24  #include "PublicDataOperations.h"  #include "PublicDataOperations.h"
25  #include "CryptoOperations.h"  #include "CryptoOperations.h"
26    #include "tlv.h"
27    
28  typedef enum _OPENPGP_FILE_TYPE  typedef enum _OPENPGP_FILE_TYPE
29  {  {
# Line 30  typedef enum _OPENPGP_FILE_TYPE Line 31  typedef enum _OPENPGP_FILE_TYPE
31          Virtual,          Virtual,
32  } OPENPGP_FILE_TYPE;  } OPENPGP_FILE_TYPE;
33    
34    #define OPENPGP_FILE_OPTIONAL 1
35    #define OPENPGP_FILE_WRITE_ONLY 2
36    #define OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING 4
37    
38  typedef struct _OPENPGP_FILE  typedef struct _OPENPGP_FILE
39  {  {
40          PCHAR szDirectory;          PCHAR szDirectory;
41          PCHAR szFile;          PCHAR szFile;
42          OPENPGP_FILE_TYPE dwFileType;          OPENPGP_FILE_TYPE dwFileType;
43          BYTE  bP1;          DWORD dwTag;
44          BYTE  bP2;          DWORD dwTlv;
45          CARD_FILE_ACCESS_CONDITION dwAccess;          CARD_FILE_ACCESS_CONDITION dwAccess;
46            DWORD dwFlag;
47  } OPENPGP_FILE, *POPENPGP_FILE;  } OPENPGP_FILE, *POPENPGP_FILE;
48    
49    
# Line 45  typedef struct _OPENPGP_FILE Line 51  typedef struct _OPENPGP_FILE
51    
52  OPENPGP_FILE Files[] =  OPENPGP_FILE Files[] =
53  {  {
54          {szOpenPGPDir, szOpenPGPFingerprint, StoredOnSmartCard, 0x00, 0xC5, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPFingerprint, StoredOnSmartCard, 0x6E, 0xC5, EveryoneReadAdminWriteAc},
55          {szOpenPGPDir, szOpenPGPStatus, StoredOnSmartCard, 0x00, 0xC4, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPStatus, StoredOnSmartCard, 0xC4, 0, EveryoneReadAdminWriteAc},
56          {szOpenPGPDir, szOpenPGPApplicationIdentifier, StoredOnSmartCard, 0x00, 0x4F, UnknownAc},          {szOpenPGPDir, szOpenPGPApplicationIdentifier, StoredOnSmartCard, 0x4F, 0, UnknownAc},
57          {szOpenPGPDir, szOpenPGPLogin, StoredOnSmartCard, 0x00, 0x5E, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPLogin, StoredOnSmartCard, 0x5E, 0, EveryoneReadAdminWriteAc},
58          {szOpenPGPDir, szOpenPGPName, StoredOnSmartCard, 0x00, 0x5B, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPName, StoredOnSmartCard, 0x65, 0x5B, EveryoneReadAdminWriteAc},
59          {szOpenPGPDir, szOpenPGPLanguage, StoredOnSmartCard, 0x5F, 0x2D, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPLanguage, StoredOnSmartCard, 0x65, 0x5F2D, EveryoneReadAdminWriteAc},
60          {szOpenPGPDir, szOpenPGPSex, StoredOnSmartCard, 0x5F, 0x35, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPSex, StoredOnSmartCard, 0x65, 0x5F35,EveryoneReadAdminWriteAc},
61          {szOpenPGPDir, szOpenPGPUrl, StoredOnSmartCard, 0x5F, 0x50, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPUrl, StoredOnSmartCard, 0x5F50, 0, EveryoneReadAdminWriteAc},
62          {szOpenPGPDir, szOpenPGPHistoricalBytes, StoredOnSmartCard, 0x5F, 0x52, UnknownAc},          {szOpenPGPDir, szOpenPGPHistoricalBytes, StoredOnSmartCard, 0x5F52, 0, UnknownAc},
63          {szOpenPGPDir, szOpenPGPCertificate, StoredOnSmartCard, 0x7F, 0x21, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPCertificate, StoredOnSmartCard, 0x7F21, 0, EveryoneReadAdminWriteAc, OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING},
64          {szOpenPGPDir, szOpenPGPExtendedCap, StoredOnSmartCard, 0x00, 0xC0, UnknownAc},          {szOpenPGPDir, szOpenPGPExtendedCap, StoredOnSmartCard, 0x6E, 0xC0, UnknownAc},
65          {szOpenPGPDir, szOpenPGPAlgoAttributesSignature, StoredOnSmartCard, 0x00, 0xC1, UnknownAc},          {szOpenPGPDir, szOpenPGPAlgoAttributesSignature, StoredOnSmartCard, 0x6E, 0xC1, UnknownAc},
66          {szOpenPGPDir, szOpenPGPAlgoAttributesDecryption, StoredOnSmartCard, 0x00, 0xC2, UnknownAc},          {szOpenPGPDir, szOpenPGPAlgoAttributesDecryption, StoredOnSmartCard, 0x6E, 0xC2,UnknownAc},
67          {szOpenPGPDir, szOpenPGPAlgoAttributesAuthentication, StoredOnSmartCard, 0x00, 0xC3, UnknownAc },          {szOpenPGPDir, szOpenPGPAlgoAttributesAuthentication, StoredOnSmartCard, 0x6E, 0xC3, UnknownAc },
68          {NULL, szCARD_IDENTIFIER_FILE, StoredOnSmartCard, 0x00, 0x4F, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPPUK, StoredOnSmartCard, 0xD3, 0, UnknownAc, OPENPGP_FILE_WRITE_ONLY },
69            {NULL, szCARD_IDENTIFIER_FILE, StoredOnSmartCard, 0x4F, 0, EveryoneReadAdminWriteAc},
70          {NULL, szCARD_APPLICATION_FILE, Virtual, 0, 0, EveryoneReadAdminWriteAc},          {NULL, szCARD_APPLICATION_FILE, Virtual, 0, 0, EveryoneReadAdminWriteAc},
71          {NULL, szCACHE_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},          {NULL, szCACHE_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},
72          {szBASE_CSP_DIR, szCONTAINER_MAP_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},          {szBASE_CSP_DIR, szCONTAINER_MAP_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},
73            {szBASE_CSP_DIR, "ksc1", StoredOnSmartCard, 0x7F21, 0, EveryoneReadAdminWriteAc, OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING},
74    
75  };  };
76    
77  DWORD dwFileCount = ARRAYSIZE(Files);  DWORD dwFileCount = ARRAYSIZE(Files);
78    
79  DWORD SCardDirectoryList(__in PCARD_DATA  pCardData,  DWORD OCardDirectoryList(__in PCARD_DATA  pCardData,
80                                          __in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)                                          __in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)
81  {  {
82          // hardcoded          // hardcoded
# Line 82  DWORD SCardDirectoryList(__in PCARD_DATA Line 90  DWORD SCardDirectoryList(__in PCARD_DATA
90          return 0;          return 0;
91  }  }
92    
93    
94  // read file  // read file
95  DWORD SCardReadFile(__in PCARD_DATA  pCardData,  DWORD OCardReadFile(__in PCARD_DATA  pCardData,
96                                          __in_opt PSTR szDirectory, __in PSTR szFile,                                          __in_opt PSTR szDirectory, __in PSTR szFile,
97                                          __in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)                                          __in PBYTE* ppbResponse, __in PDWORD pdwResponseSize)
98  {  {
99          DWORD dwI;          DWORD dwI;
100          DWORD dwReturn = 0;          DWORD dwReturn = 0;
# Line 94  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 103  DWORD SCardReadFile(__in PCARD_DATA  pCa
103          BYTE pbCmd[] = {0x00, 0xCA, 0x00, 0x00, 0x00};          BYTE pbCmd[] = {0x00, 0xCA, 0x00, 0x00, 0x00};
104          DWORD dwCmdSize = ARRAYSIZE(pbCmd);          DWORD dwCmdSize = ARRAYSIZE(pbCmd);
105          POPENPGP_CONTEXT pContext = (POPENPGP_CONTEXT) pCardData->pvVendorSpecific;          POPENPGP_CONTEXT pContext = (POPENPGP_CONTEXT) pCardData->pvVendorSpecific;
106            PBYTE pbData = NULL;
107          __try          __try
108          {          {
109                    *pdwResponseSize = 0;
110                  for(dwI = 0; dwI < dwFileCount; dwI++)                  for(dwI = 0; dwI < dwFileCount; dwI++)
111                  {                  {
112                          BOOL fMatch = FALSE;                          BOOL fMatch = FALSE;
# Line 105  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 116  DWORD SCardReadFile(__in PCARD_DATA  pCa
116                          }                          }
117                          else                          else
118                          {                          {
119                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
120                          }                          }
121                          if (fMatch)                          if (fMatch)
122                          {                          {
123                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
124                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (_stricmp(szFile, Files[dwI].szFile) == 0)
125                                  {                                  {
126                                          fFileFound = TRUE;                                          fFileFound = TRUE;
127                                          break;                                          break;
# Line 133  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 144  DWORD SCardReadFile(__in PCARD_DATA  pCa
144                  }                  }
145                  if (Files[dwI].dwFileType == StoredOnSmartCard)                  if (Files[dwI].dwFileType == StoredOnSmartCard)
146                  {                  {
147                          pbCmd[2] = Files[dwI].bP1;                          pbCmd[2] = (BYTE) (Files[dwI].dwTag / 0x100);
148                          pbCmd[3] = Files[dwI].bP2;                          pbCmd[3] = (BYTE) (Files[dwI].dwTag % 0x100);
149                          dwReturn = SCardGetData(pCardData, pbCmd, dwCmdSize, pbResponse, pdwResponseSize);                          dwReturn = OCardGetData(pCardData, pbCmd, dwCmdSize, &pbData, pdwResponseSize);
150                            if (dwReturn)
151                            {
152                                    __leave;
153                            }
154                            if (Files[dwI].dwTlv)
155                            {
156                                    PBYTE pbPointer;
157                                    //TraceDump(0,pbData,*pdwResponseSize);
158                                    if (find_tlv(pbData, Files[dwI].dwTlv, *pdwResponseSize, &pbPointer, pdwResponseSize))
159                                    {
160                                            *ppbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);
161                                            if (!*ppbResponse )
162                                            {
163                                                    Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_NO_MEMORY");
164                                                    dwReturn = SCARD_E_NO_MEMORY;
165                                            }
166                                            memcpy(*ppbResponse, pbPointer, *pdwResponseSize);
167                                    }
168                                    else
169                                    {
170                                            dwReturn = SCARD_E_FILE_NOT_FOUND;
171                                            Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
172                                    }
173                            }
174                            else
175                            {
176                                    *ppbResponse = pbData;
177                                    // do not free the data !
178                                    pbData = NULL;
179                            }
180                  }                  }
181                  else                  else
182                  {                  {
183                          if (szDirectory == NULL)                          if (szDirectory == NULL)
184                          {                          {
185                                  if (strcmp(szFile, szCARD_APPLICATION_FILE) == 0)                                  if (_stricmp(szFile, szCARD_APPLICATION_FILE) == 0)
186                                  {                                  {
187                                          dwReturn = SCardDirectoryList(pCardData, pbResponse, pdwResponseSize);                                          dwReturn = OCardDirectoryList(pCardData, ppbResponse, pdwResponseSize);
188                                  }                                  }
189                                  else if (strcmp(szFile, szCACHE_FILE) == 0)                                  else if (_stricmp(szFile, szCACHE_FILE) == 0)
190                                  {                                  {
191                                          *pdwResponseSize = sizeof(CARD_CACHE_FILE_FORMAT);                                          *pdwResponseSize = sizeof(CARD_CACHE_FILE_FORMAT);
192                                          *pbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);                                          *ppbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);
193                                          memset(*pbResponse,0,*pdwResponseSize);                                          memset(*ppbResponse,0,*pdwResponseSize);
194                                  }                                  }
195                                  else                                  else
196                                  {                                  {
# Line 157  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 198  DWORD SCardReadFile(__in PCARD_DATA  pCa
198                                          Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);                                          Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
199                                  }                                  }
200                          }                          }
201                          else if (strcmp(szDirectory,szBASE_CSP_DIR) == 0)                          else if (_stricmp(szDirectory,szBASE_CSP_DIR) == 0)
202                          {                          {
203                                  if (strcmp(szFile, szCONTAINER_MAP_FILE) == 0)                                  if (_stricmp(szFile, szCONTAINER_MAP_FILE) == 0)
204                                  {                                  {
205                                          PCONTAINER_MAP_RECORD pContainer = NULL;                                          dwReturn = OCardReadContainerMapFile(pCardData, ppbResponse, pdwResponseSize);
                                         *pdwResponseSize = sizeof(CONTAINER_MAP_RECORD) * MaxContainer;  
                                         *pbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);  
                                         if (! *pbResponse )  
                                         {  
                                                 dwReturn = SCARD_E_NO_MEMORY;  
                                                 Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_NO_MEMORY");  
                                                 __leave;  
                                         }  
                                         pContainer = (PCONTAINER_MAP_RECORD) *pbResponse;  
                                         memset(pContainer,0,sizeof(CONTAINER_MAP_RECORD) * 3);  
                                         swprintf_s(pContainer[Signature].wszGuid,MAX_CONTAINER_NAME_LEN + 1,  
                                                 L"OPENPGP_%02X%02X_%02X%02X_%02X%02X%02X%02X_Signature",  
                                                 pContext->Aid.AidVersion[0],pContext->Aid.AidVersion[1],  
                                                 pContext->Aid.AidManufacturer[0],pContext->Aid.AidManufacturer[1],  
                                                 pContext->Aid.AidSerialNumber[0],pContext->Aid.AidSerialNumber[1],  
                                                 pContext->Aid.AidSerialNumber[2],pContext->Aid.AidSerialNumber[3]);  
                                         pContainer[Signature].bFlags = CONTAINER_MAP_VALID_CONTAINER;  
                                         pContainer[Signature].wSigKeySizeBits = 1024;  
                                         swprintf_s(pContainer[Authentication].wszGuid,MAX_CONTAINER_NAME_LEN + 1,  
                                                 L"OPENPGP_%02X%02X_%02X%02X_%02X%02X%02X%02X_Authenticate",  
                                                 pContext->Aid.AidVersion[0],pContext->Aid.AidVersion[1],  
                                                 pContext->Aid.AidManufacturer[0],pContext->Aid.AidManufacturer[1],  
                                                 pContext->Aid.AidSerialNumber[0],pContext->Aid.AidSerialNumber[1],  
                                                 pContext->Aid.AidSerialNumber[2],pContext->Aid.AidSerialNumber[3]);  
                                         pContainer[Authentication].bFlags = CONTAINER_MAP_VALID_CONTAINER | CONTAINER_MAP_DEFAULT_CONTAINER;  
                                         pContainer[Authentication].wSigKeySizeBits = 1024;  
                                         swprintf_s(pContainer[Confidentiality].wszGuid,MAX_CONTAINER_NAME_LEN + 1,  
                                                 L"OPENPGP_%02X%02X_%02X%02X_%02X%02X%02X%02X_Confidential",  
                                                 pContext->Aid.AidVersion[0],pContext->Aid.AidVersion[1],  
                                                 pContext->Aid.AidManufacturer[0],pContext->Aid.AidManufacturer[1],  
                                                 pContext->Aid.AidSerialNumber[0],pContext->Aid.AidSerialNumber[1],  
                                                 pContext->Aid.AidSerialNumber[2],pContext->Aid.AidSerialNumber[3]);  
                                         pContainer[Confidentiality].bFlags = CONTAINER_MAP_VALID_CONTAINER;  
                                         pContainer[Confidentiality].wKeyExchangeKeySizeBits = 1024;  
206                                  }                                  }
207                                  else                                  else
208                                  {                                  {
# Line 219  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 226  DWORD SCardReadFile(__in PCARD_DATA  pCa
226          }          }
227          __finally          __finally
228          {          {
229                    if( pbData)
230                            pCardData->pfnCspFree(pbData);
231          }          }
232          Trace(WINEVENT_LEVEL_VERBOSE, L"%S\\%S dwReturn = 0x%08X",szDirectory, szFile, dwReturn);          Trace(WINEVENT_LEVEL_VERBOSE, L"%S\\%S dwReturn = 0x%08X size = %d",szDirectory, szFile, dwReturn, *pdwResponseSize);
233          return dwReturn;          return dwReturn;
234  }  }
235    
236  DWORD SCardEnumFile(__in PCARD_DATA  pCardData,  DWORD OCardEnumFile(__in PCARD_DATA  pCardData,
237                                          __in_opt PSTR szDirectory,                                          __in_opt PSTR szDirectory,
238                                          __in PBYTE* pbResponse, __in PDWORD pdwResponseSize)                                          __in PBYTE* pbResponse, __in PDWORD pdwResponseSize)
239  {  {
240          DWORD dwReturn = 0, dwNotExists;          DWORD dwReturn = 0, dwReadFileReturn;
241          DWORD dwI, dwSize;          DWORD dwI, dwSize;
242          BOOL fDirectoryFound = FALSE;          BOOL fDirectoryFound = FALSE;
243            BOOL fAddToOuput;
244          __try          __try
245          {          {
246                  *pbResponse = NULL;                  *pbResponse = NULL;
247                  *pdwResponseSize = 0;                  *pdwResponseSize = 0;
248                    
249                    // compute the max size of the buffer
250                    dwSize = 0;
251                  for(dwI = 0; dwI < dwFileCount; dwI++)                  for(dwI = 0; dwI < dwFileCount; dwI++)
252                  {                  {
253                          BOOL fMatch = FALSE;                          BOOL fMatch = FALSE;
# Line 245  DWORD SCardEnumFile(__in PCARD_DATA  pCa Line 257  DWORD SCardEnumFile(__in PCARD_DATA  pCa
257                          }                          }
258                          else                          else
259                          {                          {
260                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
261                            }
262                            if (fMatch && !(Files[dwI].dwFileType & OPENPGP_FILE_WRITE_ONLY))
263                            {
264                                    dwSize += (DWORD) strlen( Files[dwI].szFile) + 1;
265                            }
266                    }
267                    dwSize += 1;
268                    *pbResponse = pCardData->pfnCspAlloc(dwSize);
269                    if (!*pbResponse)
270                    {
271                            dwReturn = SCARD_E_NO_MEMORY;
272                            __leave;
273                    }
274                    for(dwI = 0; dwI < dwFileCount; dwI++)
275                    {
276                            BOOL fMatch = FALSE;
277                            if (szDirectory == NULL)
278                            {
279                                    if (!Files[dwI].szDirectory) fMatch = TRUE;
280                            }
281                            else
282                            {
283                                    if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
284                          }                          }
285                          if (fMatch)                          if (fMatch)
286                          {                          {
287                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
288                                  dwNotExists = 0;                                  fAddToOuput = TRUE;
289                                  if (StoredOnSmartCard == Files[dwI].dwFileType)                                  if (Files[dwI].dwFlag & OPENPGP_FILE_WRITE_ONLY)
290                                    {
291                                            fAddToOuput = FALSE;
292                                    }
293                                    if (fAddToOuput && (Files[dwI].dwFlag & OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING))
294                                  {                                  {
295                                          PBYTE pbData = NULL;                                          PBYTE pbData = NULL;
296                                          DWORD dwSize;                                          DWORD dwSize;
297                                            fAddToOuput = FALSE;
298                                          // check if the file exists and be read                                          // check if the file exists and be read
299                                          dwNotExists = SCardReadFile(pCardData, szDirectory, Files[dwI].szFile, &pbData, &dwSize);                                          dwReadFileReturn = OCardReadFile(pCardData, szDirectory, Files[dwI].szFile, &pbData, &dwSize);
300                                          if (!dwNotExists)                                          if (!dwReadFileReturn)
301                                          {                                          {
302                                                  pCardData->pfnCspFree(pbData);                                                  pCardData->pfnCspFree(pbData);
303                                                    if (dwSize > 0)
304                                                    {
305                                                            fAddToOuput = TRUE;
306                                                    }
307                                          }                                          }
308                                  }                                  }
309                                  if (!dwNotExists)                                  if (fAddToOuput)
310                                  {                                  {
311                                          dwSize = (DWORD) strlen( Files[dwI].szFile) + 1;                                          dwSize = (DWORD) strlen( Files[dwI].szFile) + 1;
                                         // + 1 to add the final \0  
                                         if (*pbResponse)  
                                         {  
                                                 *pbResponse = pCardData->pfnCspReAlloc(*pbResponse, *pdwResponseSize + dwSize + 1);  
                                         }  
                                         else  
                                         {  
                                                 *pbResponse = pCardData->pfnCspAlloc(*pdwResponseSize + dwSize + 1);  
                                         }  
                                         if (!*pbResponse)  
                                         {  
                                                 dwReturn = SCARD_E_NO_MEMORY;  
                                                 __leave;  
                                         }  
312                                          memcpy(*pbResponse + *pdwResponseSize,  Files[dwI].szFile, dwSize);                                          memcpy(*pbResponse + *pdwResponseSize,  Files[dwI].szFile, dwSize);
313                                          *pdwResponseSize += dwSize;                                          *pdwResponseSize += dwSize;
314                                  }                                  }
# Line 301  DWORD SCardEnumFile(__in PCARD_DATA  pCa Line 331  DWORD SCardEnumFile(__in PCARD_DATA  pCa
331  }  }
332    
333  // read file  // read file
334  DWORD SCardGetFileInfo(__in PCARD_DATA  pCardData,  DWORD OCardGetFileInfo(__in PCARD_DATA  pCardData,
335                                          __in_opt PSTR szDirectory, __in PSTR szFile,                                          __in_opt PSTR szDirectory, __in PSTR szFile,
336                                           __inout PCARD_FILE_INFO  pCardFileInfo)                                           __inout PCARD_FILE_INFO  pCardFileInfo)
337  {  {
# Line 310  DWORD SCardGetFileInfo(__in PCARD_DATA Line 340  DWORD SCardGetFileInfo(__in PCARD_DATA
340          DWORD dwSize, dwI;          DWORD dwSize, dwI;
341          __try          __try
342          {          {
343                  dwReturn = SCardReadFile(pCardData, szDirectory, szFile, &pbData, &dwSize);                  dwReturn = OCardReadFile(pCardData, szDirectory, szFile, &pbData, &dwSize);
344                  if (dwReturn)                  if (dwReturn)
345                  {                  {
346                          __leave;                          __leave;
# Line 320  DWORD SCardGetFileInfo(__in PCARD_DATA Line 350  DWORD SCardGetFileInfo(__in PCARD_DATA
350                  pCardFileInfo->AccessCondition = InvalidAc;                  pCardFileInfo->AccessCondition = InvalidAc;
351                  for(dwI = 0; dwI < dwFileCount; dwI++)                  for(dwI = 0; dwI < dwFileCount; dwI++)
352                  {                  {
353                          if ((strcmp(szDirectory, Files[dwI].szDirectory) == 0)                          BOOL fMatch = FALSE;
354                                  || (!szDirectory && !Files[dwI].szDirectory) )                          if (szDirectory == NULL)
355                          {                          {
356                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (!Files[dwI].szDirectory) fMatch = TRUE;
357                            }
358                            else
359                            {
360                                    if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
361                            }
362                            if (fMatch)
363                            {
364                                    if (_stricmp(szFile, Files[dwI].szFile) == 0)
365                                  {                                  {
366                                          pCardFileInfo->AccessCondition = Files[dwI].dwAccess;                                          pCardFileInfo->AccessCondition = Files[dwI].dwAccess;
367                                          break;                                          break;
# Line 339  DWORD SCardGetFileInfo(__in PCARD_DATA Line 377  DWORD SCardGetFileInfo(__in PCARD_DATA
377          return dwReturn;                  return dwReturn;        
378  }  }
379    
380  DWORD SCardWriteFile(__in PCARD_DATA  pCardData,  DWORD OCardWriteFile(__in PCARD_DATA  pCardData,
381                                          __in_opt PSTR szDirectory, __in PSTR szFile,                                          __in_opt PSTR szDirectory, __in PSTR szFile,
382                                          __in PBYTE pbData, __in DWORD dwSize)                                          __in PBYTE pbData, __in DWORD dwSize)
383  {  {
# Line 368  DWORD SCardWriteFile(__in PCARD_DATA  pC Line 406  DWORD SCardWriteFile(__in PCARD_DATA  pC
406                          }                          }
407                          else                          else
408                          {                          {
409                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
410                          }                          }
411                          if (fMatch)                          if (fMatch)
412                          {                          {
413                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
414                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (_stricmp(szFile, Files[dwI].szFile) == 0)
415                                  {                                  {
416                                          fFileFound = TRUE;                                          fFileFound = TRUE;
417                                          break;                                          break;
# Line 396  DWORD SCardWriteFile(__in PCARD_DATA  pC Line 434  DWORD SCardWriteFile(__in PCARD_DATA  pC
434                  }                  }
435                  if (Files[dwI].dwFileType == StoredOnSmartCard)                  if (Files[dwI].dwFileType == StoredOnSmartCard)
436                  {                  {
437                          // fail because the PUT DO doesn't work => too much data                          if (Files[dwI].dwTlv > 0)
                         if (Files[dwI].bP1 != 0)  
438                          {                          {
439                                  dwReturn = SCARD_E_WRITE_TOO_MANY ;                                  pbCmd[2] = (BYTE) (Files[dwI].dwTlv / 0x100);
440                                  Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_WRITE_TOO_MANY  %S",szFile);                                  pbCmd[3] = (BYTE) (Files[dwI].dwTlv % 0x100);
441                                  __leave;                          }
442                            else
443                            {
444                                    pbCmd[2] = (BYTE) (Files[dwI].dwTag / 0x100);
445                                    pbCmd[3] = (BYTE) (Files[dwI].dwTag % 0x100);
446                          }                          }
                         pbCmd[3] = Files[dwI].bP2;  
447                          pbCmd[4] = (BYTE) dwSize;                          pbCmd[4] = (BYTE) dwSize;
448                          if (dwSize)                          if (dwSize)
449                          {                          {
450                                  memcpy(pbCmd + 5, pbData, dwSize);                                  memcpy(pbCmd + 5, pbData, dwSize);
451                          }                          }
452                          dwCmdSize = dwSize + 5;                          dwCmdSize = dwSize + 5;
453                          dwReturn = SCardSendCommand(pCardData, pbCmd, dwCmdSize);                          dwReturn = OCardSendCommand(pCardData, pbCmd, dwCmdSize);
454                          if (dwReturn)                          if (dwReturn)
455                          {                          {
456                                  __leave;                                  __leave;
# Line 432  DWORD SCardWriteFile(__in PCARD_DATA  pC Line 472  DWORD SCardWriteFile(__in PCARD_DATA  pC
472          return dwReturn;          return dwReturn;
473  }  }
474    
475  DWORD SCardDeleteFile(__in PCARD_DATA  pCardData,  DWORD OCardDeleteFile(__in PCARD_DATA  pCardData,
476                                          __in_opt PSTR szDirectory, __in PSTR szFile)                                          __in_opt PSTR szDirectory, __in PSTR szFile)
477  {  {
478          return SCardWriteFile(pCardData, szDirectory, szFile, NULL, 0);          return OCardWriteFile(pCardData, szDirectory, szFile, NULL, 0);
479  }  }
480    
481  // just change the flag in Files  // just change the flag in Files
482  DWORD SCardCreateFile(__in PCARD_DATA  pCardData,  DWORD OCardCreateFile(__in PCARD_DATA  pCardData,
483                                          __in_opt PSTR szDirectory, __in PSTR szFile)                                          __in_opt PSTR szDirectory, __in PSTR szFile)
484  {  {
485          DWORD dwI;          DWORD dwI;
# Line 457  DWORD SCardCreateFile(__in PCARD_DATA  p Line 497  DWORD SCardCreateFile(__in PCARD_DATA  p
497                          }                          }
498                          else                          else
499                          {                          {
500                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
501                          }                          }
502                          if (fMatch)                          if (fMatch)
503                          {                          {
504                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
505                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (_stricmp(szFile, Files[dwI].szFile) == 0)
506                                  {                                  {
507                                          fFileFound = TRUE;                                          fFileFound = TRUE;
508                                          break;                                          break;
Legend:
Removed from v.1  
changed lines
  Added in v.9
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26