/[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 10 by vletoux, Mon Mar 15 18:23:17 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    #define OPENPGP_FILE_CONF_IS_AUTH 8
38    
39  typedef struct _OPENPGP_FILE  typedef struct _OPENPGP_FILE
40  {  {
41          PCHAR szDirectory;          PCHAR szDirectory;
42          PCHAR szFile;          PCHAR szFile;
43          OPENPGP_FILE_TYPE dwFileType;          OPENPGP_FILE_TYPE dwFileType;
44          BYTE  bP1;          DWORD dwTag;
45          BYTE  bP2;          DWORD dwTlv;
46          CARD_FILE_ACCESS_CONDITION dwAccess;          CARD_FILE_ACCESS_CONDITION dwAccess;
47            DWORD dwFlag;
48  } OPENPGP_FILE, *POPENPGP_FILE;  } OPENPGP_FILE, *POPENPGP_FILE;
49    
50    
# Line 45  typedef struct _OPENPGP_FILE Line 52  typedef struct _OPENPGP_FILE
52    
53  OPENPGP_FILE Files[] =  OPENPGP_FILE Files[] =
54  {  {
55          {szOpenPGPDir, szOpenPGPFingerprint, StoredOnSmartCard, 0x00, 0xC5, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPFingerprint, StoredOnSmartCard, 0x6E, 0xC5, EveryoneReadAdminWriteAc},
56          {szOpenPGPDir, szOpenPGPStatus, StoredOnSmartCard, 0x00, 0xC4, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPStatus, StoredOnSmartCard, 0xC4, 0, EveryoneReadAdminWriteAc},
57          {szOpenPGPDir, szOpenPGPApplicationIdentifier, StoredOnSmartCard, 0x00, 0x4F, UnknownAc},          {szOpenPGPDir, szOpenPGPApplicationIdentifier, StoredOnSmartCard, 0x4F, 0, UnknownAc},
58          {szOpenPGPDir, szOpenPGPLogin, StoredOnSmartCard, 0x00, 0x5E, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPLogin, StoredOnSmartCard, 0x5E, 0, EveryoneReadAdminWriteAc},
59          {szOpenPGPDir, szOpenPGPName, StoredOnSmartCard, 0x00, 0x5B, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPName, StoredOnSmartCard, 0x65, 0x5B, EveryoneReadAdminWriteAc},
60          {szOpenPGPDir, szOpenPGPLanguage, StoredOnSmartCard, 0x5F, 0x2D, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPLanguage, StoredOnSmartCard, 0x65, 0x5F2D, EveryoneReadAdminWriteAc},
61          {szOpenPGPDir, szOpenPGPSex, StoredOnSmartCard, 0x5F, 0x35, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPSex, StoredOnSmartCard, 0x65, 0x5F35,EveryoneReadAdminWriteAc},
62          {szOpenPGPDir, szOpenPGPUrl, StoredOnSmartCard, 0x5F, 0x50, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPUrl, StoredOnSmartCard, 0x5F50, 0, EveryoneReadAdminWriteAc},
63          {szOpenPGPDir, szOpenPGPHistoricalBytes, StoredOnSmartCard, 0x5F, 0x52, UnknownAc},          {szOpenPGPDir, szOpenPGPHistoricalBytes, StoredOnSmartCard, 0x5F52, 0, UnknownAc},
64          {szOpenPGPDir, szOpenPGPCertificate, StoredOnSmartCard, 0x7F, 0x21, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPCertificate, StoredOnSmartCard, 0x7F21, 0, EveryoneReadAdminWriteAc, OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING},
65          {szOpenPGPDir, szOpenPGPExtendedCap, StoredOnSmartCard, 0x00, 0xC0, UnknownAc},          {szOpenPGPDir, szOpenPGPExtendedCap, StoredOnSmartCard, 0x6E, 0xC0, UnknownAc},
66          {szOpenPGPDir, szOpenPGPAlgoAttributesSignature, StoredOnSmartCard, 0x00, 0xC1, UnknownAc},          {szOpenPGPDir, szOpenPGPAlgoAttributesSignature, StoredOnSmartCard, 0x6E, 0xC1, UnknownAc},
67          {szOpenPGPDir, szOpenPGPAlgoAttributesDecryption, StoredOnSmartCard, 0x00, 0xC2, UnknownAc},          {szOpenPGPDir, szOpenPGPAlgoAttributesDecryption, StoredOnSmartCard, 0x6E, 0xC2,UnknownAc},
68          {szOpenPGPDir, szOpenPGPAlgoAttributesAuthentication, StoredOnSmartCard, 0x00, 0xC3, UnknownAc },          {szOpenPGPDir, szOpenPGPAlgoAttributesAuthentication, StoredOnSmartCard, 0x6E, 0xC3, UnknownAc },
69          {NULL, szCARD_IDENTIFIER_FILE, StoredOnSmartCard, 0x00, 0x4F, EveryoneReadAdminWriteAc},          {szOpenPGPDir, szOpenPGPPUK, StoredOnSmartCard, 0xD3, 0, UnknownAc, OPENPGP_FILE_WRITE_ONLY },
70            {NULL, szCARD_IDENTIFIER_FILE, StoredOnSmartCard, 0x4F, 0, EveryoneReadAdminWriteAc},
71          {NULL, szCARD_APPLICATION_FILE, Virtual, 0, 0, EveryoneReadAdminWriteAc},          {NULL, szCARD_APPLICATION_FILE, Virtual, 0, 0, EveryoneReadAdminWriteAc},
72          {NULL, szCACHE_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},          {NULL, szCACHE_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},
73          {szBASE_CSP_DIR, szCONTAINER_MAP_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},          {szBASE_CSP_DIR, szCONTAINER_MAP_FILE, Virtual, 0, 0, EveryoneReadUserWriteAc},
74            {szBASE_CSP_DIR, "ksc1", StoredOnSmartCard, 0x7F21, 0, EveryoneReadAdminWriteAc, OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING | OPENPGP_FILE_CONF_IS_AUTH},
75            {szBASE_CSP_DIR, "ksc2", StoredOnSmartCard, 0x7F21, 0, EveryoneReadAdminWriteAc, OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING},
76    
77  };  };
78    
79  DWORD dwFileCount = ARRAYSIZE(Files);  DWORD dwFileCount = ARRAYSIZE(Files);
80    
81  DWORD SCardDirectoryList(__in PCARD_DATA  pCardData,  DWORD OCardDirectoryList(__in PCARD_DATA  pCardData,
82                                          __in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)                                          __in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)
83  {  {
84          // hardcoded          // hardcoded
# Line 82  DWORD SCardDirectoryList(__in PCARD_DATA Line 92  DWORD SCardDirectoryList(__in PCARD_DATA
92          return 0;          return 0;
93  }  }
94    
95    
96  // read file  // read file
97  DWORD SCardReadFile(__in PCARD_DATA  pCardData,  DWORD OCardReadFile(__in PCARD_DATA  pCardData,
98                                          __in_opt PSTR szDirectory, __in PSTR szFile,                                          __in_opt PSTR szDirectory, __in PSTR szFile,
99                                          __in PBYTE* pbResponse, __in_opt PDWORD pdwResponseSize)                                          __in PBYTE* ppbResponse, __in PDWORD pdwResponseSize)
100  {  {
101          DWORD dwI;          DWORD dwI;
102          DWORD dwReturn = 0;          DWORD dwReturn = 0;
# Line 94  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 105  DWORD SCardReadFile(__in PCARD_DATA  pCa
105          BYTE pbCmd[] = {0x00, 0xCA, 0x00, 0x00, 0x00};          BYTE pbCmd[] = {0x00, 0xCA, 0x00, 0x00, 0x00};
106          DWORD dwCmdSize = ARRAYSIZE(pbCmd);          DWORD dwCmdSize = ARRAYSIZE(pbCmd);
107          POPENPGP_CONTEXT pContext = (POPENPGP_CONTEXT) pCardData->pvVendorSpecific;          POPENPGP_CONTEXT pContext = (POPENPGP_CONTEXT) pCardData->pvVendorSpecific;
108            PBYTE pbData = NULL;
109          __try          __try
110          {          {
111                    *pdwResponseSize = 0;
112                  for(dwI = 0; dwI < dwFileCount; dwI++)                  for(dwI = 0; dwI < dwFileCount; dwI++)
113                  {                  {
114                          BOOL fMatch = FALSE;                          BOOL fMatch = FALSE;
# Line 105  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 118  DWORD SCardReadFile(__in PCARD_DATA  pCa
118                          }                          }
119                          else                          else
120                          {                          {
121                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
122                          }                          }
123                          if (fMatch)                          if (fMatch)
124                          {                          {
125                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
126                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (_stricmp(szFile, Files[dwI].szFile) == 0)
127                                  {                                  {
128                                          fFileFound = TRUE;                                          fFileFound = TRUE;
129                                          break;                                          break;
# Line 133  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 146  DWORD SCardReadFile(__in PCARD_DATA  pCa
146                  }                  }
147                  if (Files[dwI].dwFileType == StoredOnSmartCard)                  if (Files[dwI].dwFileType == StoredOnSmartCard)
148                  {                  {
149                          pbCmd[2] = Files[dwI].bP1;                          pbCmd[2] = (BYTE) (Files[dwI].dwTag / 0x100);
150                          pbCmd[3] = Files[dwI].bP2;                          pbCmd[3] = (BYTE) (Files[dwI].dwTag % 0x100);
151                          dwReturn = SCardGetData(pCardData, pbCmd, dwCmdSize, pbResponse, pdwResponseSize);                          dwReturn = OCardGetData(pCardData, pbCmd, dwCmdSize, &pbData, pdwResponseSize);
152                            if (dwReturn)
153                            {
154                                    __leave;
155                            }
156                            if (Files[dwI].dwTlv)
157                            {
158                                    PBYTE pbPointer;
159                                    //TraceDump(0,pbData,*pdwResponseSize);
160                                    if (find_tlv(pbData, Files[dwI].dwTlv, *pdwResponseSize, &pbPointer, pdwResponseSize))
161                                    {
162                                            *ppbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);
163                                            if (!*ppbResponse )
164                                            {
165                                                    Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_NO_MEMORY");
166                                                    dwReturn = SCARD_E_NO_MEMORY;
167                                            }
168                                            memcpy(*ppbResponse, pbPointer, *pdwResponseSize);
169                                    }
170                                    else
171                                    {
172                                            dwReturn = SCARD_E_FILE_NOT_FOUND;
173                                            Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
174                                    }
175                            }
176                            else
177                            {
178                                    *ppbResponse = pbData;
179                                    // do not free the data !
180                                    pbData = NULL;
181                            }
182                  }                  }
183                  else                  else
184                  {                  {
185                          if (szDirectory == NULL)                          if (szDirectory == NULL)
186                          {                          {
187                                  if (strcmp(szFile, szCARD_APPLICATION_FILE) == 0)                                  if (_stricmp(szFile, szCARD_APPLICATION_FILE) == 0)
188                                  {                                  {
189                                          dwReturn = SCardDirectoryList(pCardData, pbResponse, pdwResponseSize);                                          dwReturn = OCardDirectoryList(pCardData, ppbResponse, pdwResponseSize);
190                                  }                                  }
191                                  else if (strcmp(szFile, szCACHE_FILE) == 0)                                  else if (_stricmp(szFile, szCACHE_FILE) == 0)
192                                  {                                  {
193                                          *pdwResponseSize = sizeof(CARD_CACHE_FILE_FORMAT);                                          *pdwResponseSize = sizeof(CARD_CACHE_FILE_FORMAT);
194                                          *pbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);                                          *ppbResponse = pCardData->pfnCspAlloc(*pdwResponseSize);
195                                          memset(*pbResponse,0,*pdwResponseSize);                                          memset(*ppbResponse,0,*pdwResponseSize);
196                                  }                                  }
197                                  else                                  else
198                                  {                                  {
# Line 157  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 200  DWORD SCardReadFile(__in PCARD_DATA  pCa
200                                          Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);                                          Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_FILE_NOT_FOUND %S",szFile);
201                                  }                                  }
202                          }                          }
203                          else if (strcmp(szDirectory,szBASE_CSP_DIR) == 0)                          else if (_stricmp(szDirectory,szBASE_CSP_DIR) == 0)
204                          {                          {
205                                  if (strcmp(szFile, szCONTAINER_MAP_FILE) == 0)                                  if (_stricmp(szFile, szCONTAINER_MAP_FILE) == 0)
206                                  {                                  {
207                                          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;  
208                                  }                                  }
209                                  else                                  else
210                                  {                                  {
# Line 219  DWORD SCardReadFile(__in PCARD_DATA  pCa Line 228  DWORD SCardReadFile(__in PCARD_DATA  pCa
228          }          }
229          __finally          __finally
230          {          {
231                    if( pbData)
232                            pCardData->pfnCspFree(pbData);
233          }          }
234          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);
235          return dwReturn;          return dwReturn;
236  }  }
237    
238  DWORD SCardEnumFile(__in PCARD_DATA  pCardData,  DWORD OCardEnumFile(__in PCARD_DATA  pCardData,
239                                          __in_opt PSTR szDirectory,                                          __in_opt PSTR szDirectory,
240                                          __in PBYTE* pbResponse, __in PDWORD pdwResponseSize)                                          __in PBYTE* pbResponse, __in PDWORD pdwResponseSize)
241  {  {
242          DWORD dwReturn = 0, dwNotExists;          DWORD dwReturn = 0, dwTempReturn;
243          DWORD dwI, dwSize;          DWORD dwI, dwSize;
244          BOOL fDirectoryFound = FALSE;          BOOL fDirectoryFound = FALSE;
245            BOOL fAddToOuput;
246          __try          __try
247          {          {
248                  *pbResponse = NULL;                  *pbResponse = NULL;
249                  *pdwResponseSize = 0;                  *pdwResponseSize = 0;
250                    
251                    // compute the max size of the buffer
252                    dwSize = 0;
253                  for(dwI = 0; dwI < dwFileCount; dwI++)                  for(dwI = 0; dwI < dwFileCount; dwI++)
254                  {                  {
255                          BOOL fMatch = FALSE;                          BOOL fMatch = FALSE;
# Line 245  DWORD SCardEnumFile(__in PCARD_DATA  pCa Line 259  DWORD SCardEnumFile(__in PCARD_DATA  pCa
259                          }                          }
260                          else                          else
261                          {                          {
262                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
263                            }
264                            if (fMatch && !(Files[dwI].dwFileType & OPENPGP_FILE_WRITE_ONLY))
265                            {
266                                    dwSize += (DWORD) strlen( Files[dwI].szFile) + 1;
267                            }
268                    }
269                    dwSize += 1;
270                    *pbResponse = pCardData->pfnCspAlloc(dwSize);
271                    if (!*pbResponse)
272                    {
273                            dwReturn = SCARD_E_NO_MEMORY;
274                            __leave;
275                    }
276                    for(dwI = 0; dwI < dwFileCount; dwI++)
277                    {
278                            BOOL fMatch = FALSE;
279                            if (szDirectory == NULL)
280                            {
281                                    if (!Files[dwI].szDirectory) fMatch = TRUE;
282                            }
283                            else
284                            {
285                                    if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
286                          }                          }
287                          if (fMatch)                          if (fMatch)
288                          {                          {
289                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
290                                  dwNotExists = 0;                                  fAddToOuput = TRUE;
291                                  if (StoredOnSmartCard == Files[dwI].dwFileType)                                  if (Files[dwI].dwFlag & OPENPGP_FILE_WRITE_ONLY)
292                                    {
293                                            fAddToOuput = FALSE;
294                                    }
295                                    if (fAddToOuput && (Files[dwI].dwFlag & OPENPGP_FILE_NULL_LENGHT_EQUALS_MISSING))
296                                  {                                  {
297                                          PBYTE pbData = NULL;                                          PBYTE pbData = NULL;
298                                          DWORD dwSize;                                          DWORD dwSize;
299                                            fAddToOuput = FALSE;
300                                          // check if the file exists and be read                                          // check if the file exists and be read
301                                          dwNotExists = SCardReadFile(pCardData, szDirectory, Files[dwI].szFile, &pbData, &dwSize);                                          dwTempReturn = OCardReadFile(pCardData, szDirectory, Files[dwI].szFile, &pbData, &dwSize);
302                                          if (!dwNotExists)                                          if (!dwTempReturn)
303                                          {                                          {
304                                                  pCardData->pfnCspFree(pbData);                                                  pCardData->pfnCspFree(pbData);
305                                                    if (dwSize > 0)
306                                                    {
307                                                            fAddToOuput = TRUE;
308                                                    }
309                                          }                                          }
310                                  }                                  }
311                                  if (!dwNotExists)                                  if (fAddToOuput && (Files[dwI].dwFlag & OPENPGP_FILE_CONF_IS_AUTH))
312                                  {                                  {
313                                          dwSize = (DWORD) strlen( Files[dwI].szFile) + 1;                                          dwTempReturn = OCardIsConfidentialityKeyTheSameThanAuthentication(pCardData);
314                                          // + 1 to add the final \0                                          if (dwReturn)
                                         if (*pbResponse)  
315                                          {                                          {
316                                                  *pbResponse = pCardData->pfnCspReAlloc(*pbResponse, *pdwResponseSize + dwSize + 1);                                                  fAddToOuput = FALSE;
                                         }  
                                         else  
                                         {  
                                                 *pbResponse = pCardData->pfnCspAlloc(*pdwResponseSize + dwSize + 1);  
                                         }  
                                         if (!*pbResponse)  
                                         {  
                                                 dwReturn = SCARD_E_NO_MEMORY;  
                                                 __leave;  
317                                          }                                          }
318                                    }
319                                    if (fAddToOuput)
320                                    {
321                                            dwSize = (DWORD) strlen( Files[dwI].szFile) + 1;
322                                          memcpy(*pbResponse + *pdwResponseSize,  Files[dwI].szFile, dwSize);                                          memcpy(*pbResponse + *pdwResponseSize,  Files[dwI].szFile, dwSize);
323                                          *pdwResponseSize += dwSize;                                          *pdwResponseSize += dwSize;
324                                  }                                  }
# Line 301  DWORD SCardEnumFile(__in PCARD_DATA  pCa Line 341  DWORD SCardEnumFile(__in PCARD_DATA  pCa
341  }  }
342    
343  // read file  // read file
344  DWORD SCardGetFileInfo(__in PCARD_DATA  pCardData,  DWORD OCardGetFileInfo(__in PCARD_DATA  pCardData,
345                                          __in_opt PSTR szDirectory, __in PSTR szFile,                                          __in_opt PSTR szDirectory, __in PSTR szFile,
346                                           __inout PCARD_FILE_INFO  pCardFileInfo)                                           __inout PCARD_FILE_INFO  pCardFileInfo)
347  {  {
# Line 310  DWORD SCardGetFileInfo(__in PCARD_DATA Line 350  DWORD SCardGetFileInfo(__in PCARD_DATA
350          DWORD dwSize, dwI;          DWORD dwSize, dwI;
351          __try          __try
352          {          {
353                  dwReturn = SCardReadFile(pCardData, szDirectory, szFile, &pbData, &dwSize);                  dwReturn = OCardReadFile(pCardData, szDirectory, szFile, &pbData, &dwSize);
354                  if (dwReturn)                  if (dwReturn)
355                  {                  {
356                          __leave;                          __leave;
# Line 320  DWORD SCardGetFileInfo(__in PCARD_DATA Line 360  DWORD SCardGetFileInfo(__in PCARD_DATA
360                  pCardFileInfo->AccessCondition = InvalidAc;                  pCardFileInfo->AccessCondition = InvalidAc;
361                  for(dwI = 0; dwI < dwFileCount; dwI++)                  for(dwI = 0; dwI < dwFileCount; dwI++)
362                  {                  {
363                          if ((strcmp(szDirectory, Files[dwI].szDirectory) == 0)                          BOOL fMatch = FALSE;
364                                  || (!szDirectory && !Files[dwI].szDirectory) )                          if (szDirectory == NULL)
365                          {                          {
366                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (!Files[dwI].szDirectory) fMatch = TRUE;
367                            }
368                            else
369                            {
370                                    if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
371                            }
372                            if (fMatch)
373                            {
374                                    if (_stricmp(szFile, Files[dwI].szFile) == 0)
375                                  {                                  {
376                                          pCardFileInfo->AccessCondition = Files[dwI].dwAccess;                                          pCardFileInfo->AccessCondition = Files[dwI].dwAccess;
377                                          break;                                          break;
# Line 339  DWORD SCardGetFileInfo(__in PCARD_DATA Line 387  DWORD SCardGetFileInfo(__in PCARD_DATA
387          return dwReturn;                  return dwReturn;        
388  }  }
389    
390  DWORD SCardWriteFile(__in PCARD_DATA  pCardData,  DWORD OCardWriteFile(__in PCARD_DATA  pCardData,
391                                          __in_opt PSTR szDirectory, __in PSTR szFile,                                          __in_opt PSTR szDirectory, __in PSTR szFile,
392                                          __in PBYTE pbData, __in DWORD dwSize)                                          __in PBYTE pbData, __in DWORD dwSize)
393  {  {
# Line 368  DWORD SCardWriteFile(__in PCARD_DATA  pC Line 416  DWORD SCardWriteFile(__in PCARD_DATA  pC
416                          }                          }
417                          else                          else
418                          {                          {
419                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
420                          }                          }
421                          if (fMatch)                          if (fMatch)
422                          {                          {
423                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
424                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (_stricmp(szFile, Files[dwI].szFile) == 0)
425                                  {                                  {
426                                          fFileFound = TRUE;                                          fFileFound = TRUE;
427                                          break;                                          break;
# Line 396  DWORD SCardWriteFile(__in PCARD_DATA  pC Line 444  DWORD SCardWriteFile(__in PCARD_DATA  pC
444                  }                  }
445                  if (Files[dwI].dwFileType == StoredOnSmartCard)                  if (Files[dwI].dwFileType == StoredOnSmartCard)
446                  {                  {
447                          // fail because the PUT DO doesn't work => too much data                          if (Files[dwI].dwTlv > 0)
                         if (Files[dwI].bP1 != 0)  
448                          {                          {
449                                  dwReturn = SCARD_E_WRITE_TOO_MANY ;                                  pbCmd[2] = (BYTE) (Files[dwI].dwTlv / 0x100);
450                                  Trace(WINEVENT_LEVEL_ERROR, L"SCARD_E_WRITE_TOO_MANY  %S",szFile);                                  pbCmd[3] = (BYTE) (Files[dwI].dwTlv % 0x100);
451                                  __leave;                          }
452                            else
453                            {
454                                    pbCmd[2] = (BYTE) (Files[dwI].dwTag / 0x100);
455                                    pbCmd[3] = (BYTE) (Files[dwI].dwTag % 0x100);
456                          }                          }
                         pbCmd[3] = Files[dwI].bP2;  
457                          pbCmd[4] = (BYTE) dwSize;                          pbCmd[4] = (BYTE) dwSize;
458                          if (dwSize)                          if (dwSize)
459                          {                          {
460                                  memcpy(pbCmd + 5, pbData, dwSize);                                  memcpy(pbCmd + 5, pbData, dwSize);
461                          }                          }
462                          dwCmdSize = dwSize + 5;                          dwCmdSize = dwSize + 5;
463                          dwReturn = SCardSendCommand(pCardData, pbCmd, dwCmdSize);                          dwReturn = OCardSendCommand(pCardData, pbCmd, dwCmdSize);
464                          if (dwReturn)                          if (dwReturn)
465                          {                          {
466                                  __leave;                                  __leave;
# Line 432  DWORD SCardWriteFile(__in PCARD_DATA  pC Line 482  DWORD SCardWriteFile(__in PCARD_DATA  pC
482          return dwReturn;          return dwReturn;
483  }  }
484    
485  DWORD SCardDeleteFile(__in PCARD_DATA  pCardData,  DWORD OCardDeleteFile(__in PCARD_DATA  pCardData,
486                                          __in_opt PSTR szDirectory, __in PSTR szFile)                                          __in_opt PSTR szDirectory, __in PSTR szFile)
487  {  {
488          return SCardWriteFile(pCardData, szDirectory, szFile, NULL, 0);          return OCardWriteFile(pCardData, szDirectory, szFile, NULL, 0);
489  }  }
490    
491  // just change the flag in Files  // just change the flag in Files
492  DWORD SCardCreateFile(__in PCARD_DATA  pCardData,  DWORD OCardCreateFile(__in PCARD_DATA  pCardData,
493                                          __in_opt PSTR szDirectory, __in PSTR szFile)                                          __in_opt PSTR szDirectory, __in PSTR szFile)
494  {  {
495          DWORD dwI;          DWORD dwI;
# Line 457  DWORD SCardCreateFile(__in PCARD_DATA  p Line 507  DWORD SCardCreateFile(__in PCARD_DATA  p
507                          }                          }
508                          else                          else
509                          {                          {
510                                  if (Files[dwI].szDirectory && strcmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;                                  if (Files[dwI].szDirectory && _stricmp(szDirectory, Files[dwI].szDirectory) == 0) fMatch = TRUE;
511                          }                          }
512                          if (fMatch)                          if (fMatch)
513                          {                          {
514                                  fDirectoryFound = TRUE;                                  fDirectoryFound = TRUE;
515                                  if (strcmp(szFile, Files[dwI].szFile) == 0)                                  if (_stricmp(szFile, Files[dwI].szFile) == 0)
516                                  {                                  {
517                                          fFileFound = TRUE;                                          fFileFound = TRUE;
518                                          break;                                          break;
Legend:
Removed from v.1  
changed lines
  Added in v.10
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26