PCSC4Java  0.2
Library PCSC for Java language.
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Defines
D:/Affaire/Perso/SmartCardToolBox/pcsc4java-framework-0.2/jni/PCSC/src/PCSC.cpp
Go to the documentation of this file.
00001 /********************************************************
00002 * Copyright (c) 2011, REDBILLED All Rights Rese_lResulted
00003 *
00004 * THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF REDBILLED
00005 * The copyright notice above does not evidence any actual
00006 * or intended publication of such source code.
00007 * =======================================================
00008 * JNI for the using of PCSC
00009 * =======================================================
00010 * File : PCSC.cpp
00011 *
00012 * List of functions
00013 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardEstablishContext
00014 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardReleaseContext
00015 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardCancel
00016 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardIsValidContext
00017 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardLocateCards
00018 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardListReaders
00019 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardConnect
00020 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardTransmit
00021 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardStatus
00022 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardDisconnect
00023 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardGetStatusChange
00024 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardBeginTransaction
00025 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardEndTransaction
00026 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardControl
00027 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardReconnect
00028 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardGetAttrib
00029 *       Java_fr_redbilled_security_pcscforjava_PCSC_SCardSetAttrib
00030 *
00031 * UPDATE HISTORY
00032 *--------------------------------------------------------
00033 *Version | Author     | Date     |
00034 *--------------------------------------------------------
00035 *  1.0     ML          22/06/2011
00036 **********************************************************/
00037 
00038 #include "../inc/PCSC.h"
00039 
00040 #if(defined WIN32) || (defined WIN64)
00041 
00042         BOOL APIENTRY DllMain( HMODULE hModule,
00043                        DWORD  ul_reason_for_call,
00044                        LPVOID lpReserved
00045                                          )
00046                 {
00047                         switch (ul_reason_for_call)
00048                         {
00049                         case DLL_PROCESS_ATTACH:
00050                         case DLL_THREAD_ATTACH:
00051                         case DLL_THREAD_DETACH:
00052                         case DLL_PROCESS_DETACH:
00053                                 break;
00054                         }
00055                         return TRUE;
00056                 }
00057 
00058 #endif // #ifdef WIN32
00059 
00060 JNIEXPORT jlong JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardEstablishContext(JNIEnv * env, jclass object, jint iScope)
00061 {
00062         long                    _lResult;
00063         SCARDCONTEXT    _contextId;
00064         DWORD                   _iScope = iScope;
00065 
00066         printInDebug("--> SCardEstablishContext\n");
00067         
00068         switch(_iScope)
00069         {
00070                 case SCARD_SCOPE_USER:
00071                         printInDebug("SCardEstablishContext scope: SCARD_SCOPE_USER\n");
00072                         break;
00073                         
00074                 case SCARD_SCOPE_SYSTEM:
00075                         printInDebug("SCardEstablishContext scope: SCARD_SCOPE_SYSTEM\n");
00076                         break;
00077                 
00078                 default:
00079                         printInDebug("SCardEstablishContext scope error!\n");
00080                         printInDebug("<-- SCardTransmit Exception: %ld\n", SCARD_E_INVALID_VALUE);
00081                         launchException(env, SCARD_E_INVALID_VALUE);
00082                         return 0;
00083         }
00084 
00085         _lResult = SCardEstablishContext(_iScope, NULL, NULL, (LPSCARDCONTEXT)&_contextId);
00086         
00087         if(_lResult != SCARD_S_SUCCESS)
00088         {
00089                 printInDebug("ScardEstablishContext failed!\n");
00090                 printInDebug("<-- SCardEstablishContext Exception: %ld\n", _lResult);
00091                 launchException(env, _lResult);
00092                 return 0;
00093         }
00094         else
00095         {
00096                 printInDebug("ScardEstablishContext success %lld\n", _contextId);
00097         }
00098 
00099         printInDebug("<-- SCardEstablishContext\n");
00100         
00101         return _contextId;
00102 }
00103 
00104 JNIEXPORT void JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardReleaseContext(JNIEnv * env, jclass object, jlong lContextId)
00105 {
00106         long    _lResult;
00107         
00108         printInDebug("--> SCardReleaseContext\n");
00109         
00110         _lResult = SCardReleaseContext((SCARDCONTEXT)lContextId);
00111         if(_lResult != SCARD_S_SUCCESS)
00112         {
00113                 printInDebug("SCardReleaseContext failed!\n");
00114                 printInDebug("<-- SCardReleaseContext Exception: %ld\n", _lResult);
00115                 launchException(env, _lResult);
00116                 return;
00117         }
00118         else
00119         {       
00120                 printInDebug("SCardReleaseContext success\n");
00121         }
00122                 
00123         printInDebug("<-- SCardReleaseContext\n");
00124 }
00125 
00126 JNIEXPORT void JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardCancel(JNIEnv * env, jclass object, jlong lContextId)
00127 {
00128         long    _lResult;
00129         
00130         printInDebug("--> SCardCancel\n");
00131         
00132         _lResult = SCardCancel((SCARDCONTEXT)lContextId);
00133         if(_lResult != SCARD_S_SUCCESS)
00134         {
00135                 printInDebug("SCardCancel failed!\n");
00136                 printInDebug("<-- SCardCancel Exception: %ld\n", _lResult);
00137                 launchException(env, _lResult);
00138                 return;
00139         }
00140         else
00141         {       
00142                 printInDebug("SCardCancel success\n");
00143         }
00144                 
00145         printInDebug("<-- SCardCancel\n");
00146 }
00147 
00148 JNIEXPORT void JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardIsValidContext(JNIEnv * env, jclass object, jlong lContextId)
00149 {
00150         long _lResult;
00151 
00152         printInDebug("--> SCardIsValidContext\n");
00153         
00154         _lResult = SCardIsValidContext((SCARDCONTEXT)lContextId);
00155 
00156         if(_lResult != SCARD_S_SUCCESS)
00157         {
00158                 printInDebug("SCardIsValidContext failed!\n");
00159                 printInDebug("<-- SCardIsValidContext Exception: %ld\n", _lResult);
00160                 launchException(env, _lResult);
00161                 return;
00162         }
00163         else
00164         {       
00165                 printInDebug("SCardIsValidContext success\n");
00166         }
00167         
00168 
00169         printInDebug("<-- SCardIsValidContext\n");
00170 }
00171 
00172 JNIEXPORT jobjectArray JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardListReaders(JNIEnv * env, jclass object, jlong lContextId)
00173 {
00174         long                    _lResult;
00175         LPTSTR                  _psReadersList  = NULL;
00176         DWORD                   _lenReadersList;
00177         DWORD                   _i,_j,_z;
00178         BOOL                    _bIsReaderOk = false;
00179         CHAR                    _szReader[NB_MAX_READERS_SUPPORTED][READER_NAME_SZ];
00180         jobjectArray    _objReturn = NULL;
00181         
00182         printInDebug("--> SCardListReaders\n");
00183         
00184         _lResult = SCardListReaders((SCARDCONTEXT)lContextId, NULL, NULL, &_lenReadersList);
00185         if(_lResult != SCARD_S_SUCCESS)
00186         {
00187                 printInDebug("ScardListReaders failed!\n");
00188                 printInDebug("<-- SCardListReaders Exception: %ld\n", _lResult);
00189                 launchException(env, _lResult);
00190                 return NULL;
00191         }
00192         
00193         printInDebug("ScardListReaders Success with length: %ld!\n", _lenReadersList);
00194 
00195         _psReadersList = (LPTSTR) malloc(_lenReadersList);
00196 
00197         _lResult = SCardListReaders((SCARDCONTEXT)lContextId, NULL, (LPTSTR)_psReadersList, &_lenReadersList);
00198         if(_lResult != SCARD_S_SUCCESS)
00199         {
00200                 printInDebug("ScardListReaders failed!\n");
00201                 printInDebug("<-- SCardListReaders Exception: %ld\n", _lResult);
00202                 free(_psReadersList);
00203                 launchException(env, _lResult);
00204                 return NULL;
00205         }
00206         else
00207         {
00208                 for (_i=0; _i < NB_MAX_READERS_SUPPORTED; _i++)
00209                         memset(&_szReader[_i][0],0, sizeof(&_szReader[_i][0]));
00210 
00211                 if (_lenReadersList > 2) // \0\0
00212                 {
00213                         _z = 0;
00214                         _j = 0;
00215                         
00216                         for (_i = 0; _i < _lenReadersList; _i =_i + 1)
00217             {
00218                                 memcpy(&_szReader[_j][_z], &_psReadersList[_i], 1);
00219 
00220                                 if (_psReadersList[_i] == '\0')
00221                                 {
00222                                         _z = 0;
00223                                         _j++;
00224 
00225                                         if(_i < _lenReadersList-1)
00226                                                 printInDebug("SCardListReaders New reader found %s\n", _szReader[_j-1]); 
00227                                 }
00228                                 else
00229                                 {
00230                                         _z++;
00231                                 }
00232                         }
00233                 }
00234                 else
00235                 {
00236                         printInDebug("Scard List Readers failed!\n");
00237                         printInDebug("<-- SCardListReaders Exception: %ld\n", SCARD_E_NO_READERS_AVAILABLE);
00238                         free(_psReadersList);
00239                         launchException(env, SCARD_E_NO_READERS_AVAILABLE);
00240                         return NULL;
00241                 }
00242 
00243                 // The last index is just the end of the string not a complete reader name
00244                 _j--;
00245 
00246                 printInDebug("SCardListReaders Retrieving Readers Names Success: %d reader(s) found!\n", _j);
00247 
00248                 _objReturn = (jobjectArray)env->NewObjectArray(_j, env->FindClass("java/lang/String"), env->NewStringUTF(""));
00249 
00250                 for(_i = 0; _i < _j; _i++) 
00251                         env->SetObjectArrayElement(_objReturn, _i, env->NewStringUTF(_szReader[_i]));
00252         }
00253 
00254         free(_psReadersList);
00255 
00256         printInDebug("<-- SCardListReaders\n");
00257 
00258         return _objReturn;
00259 }
00260 
00261 JNIEXPORT jlong JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardConnect(JNIEnv *env, jclass object, jlong lContextId, jstring sReaderName, 
00262                                                                                                                                                                  jint iShareMode, jint iPreferredProtocols)
00263 {
00264         long            _lResult;
00265         SCARDHANDLE _cardHandle;
00266         DWORD           _activeProtocol;
00267         const CHAR      *_szReaderName = NULL;
00268         
00269         printInDebug("--> SCardConnect\n");
00270         
00271         switch(iShareMode)
00272     {
00273         case SCARD_SHARE_SHARED:
00274             printInDebug("SCardConnect SCARD_SHARE_SHARED\n");
00275             break;
00276 
00277         case SCARD_SHARE_EXCLUSIVE:
00278             printInDebug("SCardConnect SCARD_SHARE_EXCLUSIVE\n");
00279             break;
00280 
00281                 case SCARD_SHARE_DIRECT:
00282                         printInDebug("SCardConnect SCARD_SHARE_DIRECT\n");
00283                         break;
00284 
00285         default:
00286             printInDebug("SCardConnect incorrect share mode\n");
00287             printInDebug("<-- SCardConnect Exception: %ld\n", SCARD_E_INVALID_VALUE);
00288                         launchException(env, SCARD_E_INVALID_VALUE);
00289             return 0;
00290     }
00291 
00292     switch(iPreferredProtocols)
00293     {
00294                 case SCARD_PROTOCOL_UNDEFINED:
00295                         printInDebug("SCardConnect SCARD_PROTOCOL_UNDEFINED\n");
00296                         break;
00297         
00298                 case SCARD_PROTOCOL_T0:
00299             printInDebug("SCardConnect SCARD_PROTOCOL_T0\n");
00300             break;
00301 
00302         case SCARD_PROTOCOL_T1:
00303             printInDebug("SCardConnect SCARD_PROTOCOL_T1\n");
00304             break;
00305 
00306         case SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1:
00307             printInDebug("SCardConnect SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1\n");
00308             break;
00309 
00310         default:
00311             printInDebug("SCardConnect incorrect preferred protocols\n");
00312             printInDebug("<-- SCardConnect Exception: %ld\n", SCARD_E_INVALID_VALUE);
00313                         launchException(env, SCARD_E_INVALID_VALUE);
00314                         return 0;
00315     }
00316         
00317         _szReaderName = env->GetStringUTFChars((jstring)sReaderName, 0);
00318         
00319         printInDebug("SCardConnect %s\n", _szReaderName);
00320         
00321         _lResult = SCardConnect((SCARDCONTEXT)lContextId, _szReaderName, iShareMode, iPreferredProtocols, &_cardHandle, &_activeProtocol);
00322         
00323         if(_lResult != SCARD_S_SUCCESS)
00324         {
00325                 printInDebug("SCardConnect failed!\n");
00326                 printInDebug("<-- SCardConnect Exception: %ld\n", _lResult);
00327                 launchException(env, _lResult);
00328                 return 0;
00329         }
00330         else
00331         {       
00332                 printInDebug("SCardConnect success!\n");
00333                 
00334                 // Display the active protocol.
00335                 switch (_activeProtocol)
00336                 {
00337                         case SCARD_PROTOCOL_T0:
00338                                 printInDebug("SCardConnect Active protocol T0\n"); 
00339                                 break;
00340 
00341                         case SCARD_PROTOCOL_T1:
00342                                 printInDebug("SCardConnect Active protocol T1\n"); 
00343                                 break;
00344 
00345                         case SCARD_PROTOCOL_RAW:
00346                                 printInDebug("SCardConnect Active protocol RAW\n"); 
00347                                 break;
00348 
00349                         case SCARD_PROTOCOL_UNDEFINED:
00350                         default:
00351                                 printInDebug("SCardConnect Active protocol unnegotiated or unknown\n"); 
00352                                 break;
00353                 }
00354         }
00355 
00356         printInDebug("<-- SCardConnect\n");
00357 
00358         return _cardHandle;
00359 }
00360 
00361 JNIEXPORT jbyteArray JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardTransmit(JNIEnv *env, jclass object, jlong lCardHandle, jint iProtocol, 
00362                                                                                                                                                                            jbyteArray pBCommand, jint iOffset, jint iLength)
00363 
00364 {
00365         long                                    _lResult;
00366         BYTE                                    _pBResponse[BUFFER_MAX_SZ];
00367         LPSCARD_IO_REQUEST              _protocolResponse = NULL;
00368         LPCSCARD_IO_REQUEST             _protocolCurrent;
00369         DWORD                                   _dwLength = BUFFER_MAX_SZ;
00370         jbyteArray                              _objReturn = NULL;
00371         BYTE                                    *_pBCommand;
00372         
00373         printInDebug("--> SCardTransmit\n");
00374 
00375         _pBCommand = (BYTE *) (env)->GetByteArrayElements(pBCommand, NULL);
00376 
00377         switch(iProtocol)
00378         {
00379                 case SCARD_PROTOCOL_T0:
00380                         _protocolCurrent = SCARD_PCI_T0;
00381                         printInDebug("SCardTransmit Protocol current: SCARD_PCI_T0\n");
00382                         break;
00383 
00384                 case SCARD_PROTOCOL_T1:
00385                         _protocolCurrent = SCARD_PCI_T1;
00386                         printInDebug("SCardTransmit Protocol current: SCARD_PCI_T1\n");
00387                         break;
00388 
00389                 case SCARD_PROTOCOL_RAW:
00390                         _protocolCurrent = SCARD_PCI_RAW;
00391                         printInDebug("SCardTransmit Protocol current: SCARD_PCI_RAW\n");
00392                         break;
00393 
00394                 default:
00395                         printInDebug("SCardTransmit Protocol error!\n");
00396                         printInDebug("<-- SCardTransmit Exception: %ld\n", SCARD_E_INVALID_VALUE);
00397                         launchException(env, SCARD_E_INVALID_VALUE);
00398                         return NULL;
00399         }
00400 
00401         printInDebug("SCardTransmit length: %d command: %#x %#x ... %#x %#x\n", iLength, _pBCommand[0], _pBCommand[1], _pBCommand[iLength - 2], _pBCommand[iLength - 1]);
00402 
00403         _lResult = SCardTransmit((SCARDHANDLE)lCardHandle, _protocolCurrent, _pBCommand, iLength, _protocolResponse, _pBResponse, &_dwLength);
00404         if(_lResult != SCARD_S_SUCCESS)
00405         {
00406                 printInDebug("SCardTransmit failed!\n");
00407                 printInDebug("<-- SCardTransmit Exception: %ld\n", _lResult);
00408                 launchException(env, _lResult);
00409                 return NULL;
00410         }
00411         else
00412         {
00413                 printInDebug("SCardTransmit success %d data retrieved\n", _dwLength);
00414 
00415                 if(_dwLength > 0)
00416                 {
00417                         _objReturn = (jbyteArray)env->NewByteArray(_dwLength);
00418                         env->SetByteArrayRegion(_objReturn, 0, _dwLength, (jbyte*)_pBResponse);
00419                         printInDebug("SCardTransmit success card response %d bytes: %#x %#x ... %#x %#x\n", _dwLength, _pBResponse[0], _pBResponse[1], 
00420                                 _pBResponse[_dwLength-2], _pBResponse[_dwLength-1]);
00421                 }
00422                 else
00423                 {
00424                         printInDebug("<-- SCardTransmit Invalid card response\n");
00425                         launchException(env, SCARD_E_INVALID_VALUE);
00426                         return NULL;
00427                 }
00428         }
00429 
00430         (env)->ReleaseByteArrayElements(pBCommand, (jbyte *)_pBCommand, JNI_ABORT);
00431 
00432         printInDebug("<-- SCardTransmit\n");
00433 
00434         return _objReturn;
00435 }
00436 
00437 JNIEXPORT jbyteArray JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardStatus(JNIEnv *env, jclass object, jlong lCardHandle, 
00438                                                                                                                                                                          jbyteArray pBStatus, jobjectArray psReaderNames)
00439 {
00440         long            _lResult;
00441         jbyteArray      _objReturn = NULL;
00442         CHAR            _szReaderName[1][READER_NAME_SZ];
00443         DWORD           _dwReaderLength = READER_NAME_SZ;
00444         BYTE            *_pBStatus = (BYTE*)env->GetByteArrayElements(pBStatus, NULL);
00445         DWORD           _pdwState;
00446         DWORD           _pdwProtocol;
00447         BYTE            _pBAtr[ATR_LENGTH];
00448         DWORD           _dwAtrLength;
00449                 
00450         printInDebug("--> SCardStatus\n");
00451 
00452         if(env->GetArrayLength(pBStatus) != 2)
00453         {
00454                 printInDebug("SCardStatus parameter error\n");
00455                 printInDebug("<-- SCardStatus Exception: %ld\n", SCARD_E_INVALID_VALUE);
00456                 launchException(env, SCARD_E_INVALID_VALUE);
00457                 return NULL;
00458         }
00459         
00460         _pdwState = _pBStatus[0];
00461         _pdwProtocol = _pBStatus[1];
00462 
00463         printInDebug("SCardStatus State %d Protocol %d\n", _pdwState, _pdwProtocol);
00464 
00465         _lResult = SCardStatus((SCARDHANDLE)lCardHandle, _szReaderName[0], &_dwReaderLength, &_pdwState, &_pdwProtocol, _pBAtr, &_dwAtrLength);
00466         if(_lResult != SCARD_S_SUCCESS)
00467         {
00468                 printInDebug("SCardStatus failed!\n");
00469                 printInDebug("<-- SCardStatus Exception: %ld\n", _lResult);
00470                 launchException(env, _lResult);
00471                 return NULL;
00472         }
00473         else
00474         {
00475                 printInDebug("SCardStatus success for reader: %s\n", _szReaderName[0]);
00476 
00477                 switch(_pdwState)
00478                 {
00479                         case SCARD_ABSENT:
00480                                 printInDebug("SCardStatus state SCARD_ABSENT\n");
00481                                 break;
00482 
00483                         case SCARD_PRESENT:
00484                                 printInDebug("SCardStatus state SCARD_PRESENT\n");
00485                                 break;
00486 
00487                         case SCARD_SWALLOWED:
00488                                 printInDebug("SCardStatus state SCARD_SWALLOWED\n");
00489                                 break;
00490 
00491                         case SCARD_POWERED:
00492                                 printInDebug("SCardStatus state SCARD_POWERED\n");
00493                                 break;
00494 
00495                         case SCARD_NEGOTIABLE:
00496                                 printInDebug("SCardStatus state SCARD_NEGOTIABLE\n");
00497                                 break;
00498 
00499                         case SCARD_SPECIFIC:
00500                                 printInDebug("SCardStatus state SCARD_SPECIFIC\n");
00501                                 break;
00502 
00503                         case SCARD_UNKNOWN:
00504                                 printInDebug("SCardStatus state SCARD_UNKNOWN\n");
00505                                 break;
00506                         
00507                         default:
00508                                 printInDebug("SCardStatus state error\n");
00509                                 printInDebug("<-- SCardStatus Exception: %ld\n", SCARD_E_INVALID_VALUE);
00510                                 launchException(env, SCARD_E_INVALID_VALUE);
00511                                 return NULL;
00512                 }
00513 
00514                 // Display the active protocol.
00515                 switch (_pdwProtocol)
00516                 {
00517                         case SCARD_PROTOCOL_T0:
00518                                 printInDebug("SCardStatus Active protocol T0\n"); 
00519                                 break;
00520 
00521                         case SCARD_PROTOCOL_T1:
00522                                 printInDebug("SCardStatus Active protocol T1\n"); 
00523                                 break;
00524 
00525                         case SCARD_PROTOCOL_RAW:
00526                                 printInDebug("SCardStatus Active protocol RAW\n"); 
00527                                 break;
00528 
00529                         case SCARD_PROTOCOL_UNDEFINED:
00530                         default:
00531                                 printInDebug("SCardStatus Active protocol unnegotiated or unknown\n"); 
00532                                 break;
00533                 }
00534                 
00535                 if(_dwAtrLength > 0)
00536                 {
00537                         jstring _strFinal;
00538 
00539                         printInDebug("SCardStatus ATR %d bytes %#x %#x ... %#x %#x\n", _dwAtrLength, _pBAtr[0], _pBAtr[1], _pBAtr[_dwAtrLength-2], _pBAtr[_dwAtrLength-1]);
00540                         
00541                         _objReturn = (jbyteArray)env->NewByteArray(_dwAtrLength);
00542                         env->SetByteArrayRegion(_objReturn, 0, _dwAtrLength, (jbyte*)_pBAtr);
00543                         
00544                         _pBStatus[0] = (BYTE)_pdwState;
00545                         _pBStatus[1] = (BYTE)_pdwProtocol;
00546                         
00547                         env->SetByteArrayRegion(pBStatus, 0, 1, (jbyte*)_pBStatus);
00548                         env->SetByteArrayRegion(pBStatus, 1, 1, (jbyte*)&_pBStatus[1]);
00549 
00550                         printInDebug("SCardStatus %s\n", _szReaderName[0]);
00551                         _strFinal = env->NewStringUTF(_szReaderName[0]);
00552                         env->SetObjectArrayElement(psReaderNames, 0, _strFinal);
00553                 }
00554                 else
00555                 {
00556                         printInDebug("SCardStatus ATR error\n");
00557                         printInDebug("<-- SCardStatus Exception: %ld\n", SCARD_E_INVALID_VALUE);
00558                         launchException(env, SCARD_E_INVALID_VALUE);
00559                         return NULL;
00560                 }
00561         }
00562 
00563         printInDebug("<-- SCardStatus\n");
00564 
00565         return _objReturn;
00566 }
00567 
00568 JNIEXPORT void JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardDisconnect(JNIEnv *env, jclass object, jlong lCardHandle, jint iDisposition)
00569 {
00570         long _lResult;
00571 
00572         printInDebug("--> SCardDisconnect\n");
00573 
00574         switch(iDisposition)
00575         {
00576                 case SCARD_LEAVE_CARD:
00577                         printInDebug("SCardDisconnect SCARD_LEAVE_CARD\n");
00578                         break;
00579                 
00580                 case SCARD_RESET_CARD:
00581                         printInDebug("SCardDisconnect SCARD_RESET_CARD\n");
00582                         break;
00583 
00584                 case SCARD_UNPOWER_CARD:
00585                         printInDebug("SCardDisconnect SCARD_UNPOWER_CARD\n");
00586                         break;
00587 
00588                 case SCARD_EJECT_CARD:
00589                         printInDebug("SCardDisconnect PCSC_SCARD_EJECT_CARD\n");
00590                         break;
00591 
00592                 default:
00593                         printInDebug("<-- SCardDisconnect Exception: %ld\n", SCARD_E_INVALID_VALUE);
00594                         launchException(env, SCARD_E_INVALID_VALUE);
00595                         return;
00596         }
00597 
00598         _lResult = SCardDisconnect((SCARDHANDLE)lCardHandle, iDisposition);
00599         if(_lResult != SCARD_S_SUCCESS)
00600         {
00601                 printInDebug("<-- SCardDisconnect Exception: %ld\n", _lResult);
00602                 launchException(env, _lResult);
00603         }
00604 
00605         printInDebug("<-- SCardDisconnect\n");
00606 }
00607 
00608 JNIEXPORT jintArray JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardGetStatusChange(JNIEnv *env, jclass object, jlong lContextId, 
00609                                                                                                                                                                                          jlong lTimeout, jintArray piCurrentState, 
00610                                                                                                                                                                                          jobjectArray psReaderNames)
00611 {
00612 
00613         long                            _lResult;
00614         SCARDCONTEXT            _contextId = (SCARDCONTEXT)lContextId;
00615         DWORD                           _dwNbElements = env->GetArrayLength(piCurrentState);
00616         SCARD_READERSTATE       *_readerState = (SCARD_READERSTATE *)malloc(_dwNbElements * sizeof(SCARD_READERSTATE));
00617         jintArray                       _objReturn = (jintArray)env->NewIntArray(_dwNbElements);
00618         DWORD                           _i = 0;
00619         int                                     *_piCurrentState = (int*)env->GetIntArrayElements(piCurrentState, NULL);
00620 
00621         printInDebug("--> SCardGetStatusChange context: %lld\n", lContextId);
00622 
00623         memset(_readerState, 0, _dwNbElements * sizeof(SCARD_READERSTATE));
00624         
00625         if(_dwNbElements != env->GetArrayLength(piCurrentState))
00626         {
00627                 printInDebug("<-- SCardGetStatusChange %d - %d Exception: %ld\n", _dwNbElements, env->GetArrayLength(piCurrentState), SCARD_E_INVALID_VALUE);
00628                 launchException(env, SCARD_E_INVALID_VALUE);
00629                 return NULL;
00630         }
00631 
00632         for(_i = 0; _i < _dwNbElements; _i++)
00633         {
00634                 printInDebug("SCardGetStatusChange current state:\n");
00635 
00636                 if(_piCurrentState[_i] == SCARD_STATE_UNAWARE)
00637                         printInDebug("\tSCARD_STATE_UNAWARE\n");
00638                 if((_piCurrentState[_i] & SCARD_STATE_IGNORE) == SCARD_STATE_IGNORE)
00639                         printInDebug("\tSCARD_STATE_IGNORE\n");
00640                 if((_piCurrentState[_i] & SCARD_STATE_UNAVAILABLE) == SCARD_STATE_UNAVAILABLE)
00641                         printInDebug("\tSCARD_STATE_UNAVAILABLE\n");
00642                 if((_piCurrentState[_i] & SCARD_STATE_EMPTY) == SCARD_STATE_EMPTY)
00643                         printInDebug("\tSCARD_STATE_EMPTY\n");
00644                 if((_piCurrentState[_i] & SCARD_STATE_PRESENT) == SCARD_STATE_PRESENT)
00645                         printInDebug("\tSCARD_STATE_PRESENT\n");
00646                 if((_piCurrentState[_i] & SCARD_STATE_ATRMATCH) == SCARD_STATE_ATRMATCH)
00647                         printInDebug("\tSCARD_STATE_ATRMATCH\n");
00648                 if((_piCurrentState[_i] & SCARD_STATE_EXCLUSIVE) == SCARD_STATE_EXCLUSIVE)
00649                         printInDebug("\tSCARD_STATE_EXCLUSIVE\n");
00650                 if((_piCurrentState[_i] & SCARD_STATE_INUSE) == SCARD_STATE_INUSE)
00651                         printInDebug("\tSCARD_STATE_INUSE\n");
00652                 if((_piCurrentState[_i] & SCARD_STATE_MUTE) == SCARD_STATE_MUTE)
00653                         printInDebug("\tSCARD_STATE_MUTE\n");
00654                 
00655                 
00656                 jobject _jReaderName = env->GetObjectArrayElement(psReaderNames, _i);
00657                 _readerState[_i].szReader = env->GetStringUTFChars((jstring)_jReaderName, 0);
00658                 _readerState[_i].pvUserData = NULL;
00659                 _readerState[_i].dwCurrentState = _piCurrentState[_i];
00660                 _readerState[_i].dwEventState = SCARD_STATE_UNAWARE;
00661                 _readerState[_i].cbAtr = 0;
00662 
00663                 printInDebug("SCardGetStatusChange %d reader: %s - current %d - event %d \n", _i, _readerState[_i].szReader, _readerState[_i].dwCurrentState, _readerState[_i].dwEventState);
00664         }
00665 
00666         env->ReleaseIntArrayElements(piCurrentState, (jint*)_piCurrentState, JNI_ABORT);
00667 
00668         printInDebug("SCardGetStatusChange %d elements ready to test\n", _dwNbElements);
00669 
00670         printInDebug("SCardGetStatusChange timeout: %d \n", lTimeout);
00671 
00672         _lResult = SCardGetStatusChange((SCARDCONTEXT)_contextId, (long)lTimeout, _readerState, _dwNbElements);
00673 
00674         if(_lResult != SCARD_S_SUCCESS)
00675         {
00676                 printInDebug("<-- SCardGetStatusChange Exception: %ld\n", _lResult);
00677                 launchException(env, _lResult);
00678                 return NULL;
00679         }
00680         else
00681         {
00682                 printInDebug("SCardGetStatusChange %ld new states retrieved\n", _dwNbElements);
00683                 
00684                 for(_i = 0; _i < _dwNbElements; _i++)
00685                 {
00686                         jint _eventStateTmp;
00687 
00688                         _eventStateTmp = ((jint) _readerState[_i].dwEventState);
00689 
00690                         printInDebug("SCardGetStatusChange nb bytes atr %d \n", _readerState[_i].cbAtr);
00691                         
00692                         printInDebug("SCardGetStatusChange event state %d: \n", _eventStateTmp);
00693 
00694                         if(_eventStateTmp == SCARD_STATE_UNAWARE)
00695                                 printInDebug("\tSCARD_STATE_UNAWARE\n");
00696                         if((_eventStateTmp & SCARD_STATE_IGNORE) == SCARD_STATE_IGNORE)
00697                                 printInDebug("\tSCARD_STATE_IGNORE\n");
00698                         if((_eventStateTmp & SCARD_STATE_UNAVAILABLE) == SCARD_STATE_UNAVAILABLE)
00699                                 printInDebug("\tSCARD_STATE_UNAVAILABLE\n");
00700                         if((_eventStateTmp & SCARD_STATE_EMPTY) == SCARD_STATE_EMPTY)
00701                                 printInDebug("\tSCARD_STATE_EMPTY\n");
00702                         if((_eventStateTmp & SCARD_STATE_PRESENT) == SCARD_STATE_PRESENT)
00703                                 printInDebug("\tSCARD_STATE_PRESENT\n");
00704                         if((_eventStateTmp & SCARD_STATE_ATRMATCH) == SCARD_STATE_ATRMATCH)
00705                                 printInDebug("\tSCARD_STATE_ATRMATCH\n");
00706                         if((_eventStateTmp & SCARD_STATE_EXCLUSIVE) == SCARD_STATE_EXCLUSIVE)
00707                                 printInDebug("\tSCARD_STATE_EXCLUSIVE\n");
00708                         if((_eventStateTmp & SCARD_STATE_INUSE) == SCARD_STATE_INUSE)
00709                                 printInDebug("\tSCARD_STATE_INUSE\n");
00710                         if((_eventStateTmp & SCARD_STATE_MUTE) == SCARD_STATE_MUTE)
00711                                 printInDebug("\tSCARD_STATE_MUTE\n");
00712                         
00713                         env->SetIntArrayRegion(_objReturn, _i, 1, &_eventStateTmp);
00714                 }
00715         }
00716 
00717         free(_readerState);
00718 
00719         printInDebug("<-- SCardGetStatusChange\n");
00720 
00721         return _objReturn;
00722 }
00723 
00724 JNIEXPORT jboolean JNICALL Java_fr_redbilled_security_pcscforjava_PCSCTerminals_SCardIsPlugAndPlaySupported(JNIEnv *env, jclass object, jlong lContextId)
00725 {
00726         long                            _lResult;
00727         SCARDCONTEXT            _contextId = (SCARDCONTEXT)lContextId;
00728         SCARD_READERSTATE       _readerState[1];
00729                 
00730         printInDebug("--> SCardIsPlugAndPlaySupported context: %lld\n", lContextId);
00731 
00732         _readerState[0].szReader = "\\\\?PnP?\\Notification";
00733         _readerState[0].pvUserData = NULL;
00734         _readerState[0].dwCurrentState = SCARD_STATE_UNAWARE;
00735         _readerState[0].dwEventState = SCARD_STATE_UNAWARE;
00736         _readerState[0].cbAtr = 0;
00737 
00738         printInDebug("SCardIsPlugAndPlaySupported timeout: %d \n", 1);
00739 
00740         _lResult = SCardGetStatusChange((SCARDCONTEXT)_contextId, (long)1, _readerState, 1);
00741 
00742         printInDebug("<-- SCardIsPlugAndPlaySupported %d\n", _lResult);
00743 
00744         if((_lResult != SCARD_S_SUCCESS) || ((_readerState[0].dwEventState & SCARD_STATE_UNKNOWN) == SCARD_STATE_UNKNOWN))
00745                 return false;
00746         else
00747                 return true;    
00748 }
00749 
00750 JNIEXPORT jboolean JNICALL Java_fr_redbilled_security_pcscforjava_PCSCPnPThread_SCardPlugAndPlay(JNIEnv *env, jclass object, jlong lContextId, jlong lTimeout)
00751 {
00752 
00753         long                            _lResult;
00754         SCARDCONTEXT            _contextId = (SCARDCONTEXT)lContextId;
00755         SCARD_READERSTATE       _readerState[1];
00756         
00757         
00758         printInDebug("--> SCardPlugAndPlay context: %lld\n", lContextId);
00759 
00760         if(g_lContextIdForPnPManagement != lContextId)
00761         {
00762                 _readerState[0].szReader = "\\\\?PnP?\\Notification";
00763                 _readerState[0].pvUserData = NULL;
00764                 _readerState[0].dwCurrentState = SCARD_STATE_UNAWARE;
00765                 _readerState[0].dwEventState = SCARD_STATE_UNAWARE;
00766                 _readerState[0].cbAtr = 0;
00767 
00768                 printInDebug("SCardPlugAndPlay timeout: %d \n", lTimeout);
00769 
00770                 _lResult = SCardGetStatusChange((SCARDCONTEXT)_contextId, (long)lTimeout, _readerState, 1);
00771 
00772                 if((_lResult != SCARD_S_SUCCESS) || ((_readerState[0].dwEventState & SCARD_STATE_UNKNOWN) == SCARD_STATE_UNKNOWN))
00773                 {
00774                         printInDebug("SCardPlugAndPlay native plug and play not supported result: %d & event %d \n", _lResult, _readerState[0].dwEventState);
00775                         g_bPnP = false;
00776                 }
00777                 else
00778                 {
00779                         printInDebug("SCardPlugAndPlay native plug and play is supported \n");
00780                         g_bPnP = true;
00781                 }
00782 
00783                 g_lContextIdForPnPManagement = (SCARDCONTEXT)lContextId;
00784                 g_lEventOccured = _readerState[0].dwEventState;
00785         }
00786 
00787         if(g_bPnP)
00788         {
00789                 _readerState[0].szReader = "\\\\?PnP?\\Notification";
00790                 _readerState[0].pvUserData = NULL;
00791                 _readerState[0].dwCurrentState = g_lEventOccured;
00792                 _readerState[0].dwEventState = SCARD_STATE_UNAWARE;
00793                 _readerState[0].cbAtr = 0;
00794                 
00795                 _lResult = SCardGetStatusChange((SCARDCONTEXT)_contextId, (long)lTimeout, _readerState, 1);
00796 
00797                 if(_lResult == SCARD_E_TIMEOUT)
00798                 {
00799                         printInDebug("<-- SCardPlugAndPlay SCARD_E_TIMEOUT\n"); 
00800                         return false;
00801                 }
00802                 else if(_lResult == SCARD_S_SUCCESS)
00803                 {
00804                         printInDebug("<-- SCardPlugAndPlay SCARD_S_SUCCESS\n");         
00805                         g_lEventOccured = _readerState[0].dwEventState;
00806                         return true;
00807                 }
00808                 else
00809                 {
00810                         printInDebug("<-- SCardPlugAndPlay Exception: %ld\n", _lResult);
00811                         launchException(env, _lResult);
00812                         return false;
00813                 }
00814         }
00815         else
00816         {
00817                 printInDebug("<-- SCardPlugAndPlay WARNING NOT IMPLEMENTED\n");
00818         }
00819         
00820         return false;
00821 }
00822 
00823 JNIEXPORT jintArray JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardLocateCards(JNIEnv *env, jclass object, jlong lContextId, 
00824                                                                                                                                                                                  jobjectArray psCardNames, jintArray piCurrentState, 
00825                                                                                                                                                                                  jobjectArray psReaderNames)
00826 {
00827         /*long _lResult;
00828 
00829         printInDebug("--> SCardLocateCards\n");
00830 
00831         _lResult = SCardLocateCards((long)lContextId, 
00832 
00833         if(_lResult != SCARD_S_SUCCESS)
00834         {
00835                 printInDebug("<-- SCardLocateCards Exception: %ld\n", _lResult);
00836                 launchException(env, _lResult);
00837                 return NULL;
00838         }
00839         else
00840         {
00841                 printInDebug("SCardLocateCards success\n");
00842         }
00843 
00844         printInDebug("<-- SCardLocateCards\n");*/
00845 
00846         return NULL;
00847 }
00848 
00849 JNIEXPORT void JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardBeginTransaction(JNIEnv *env, jclass object, jlong lCardHandle)
00850 {
00851         long _lResult;
00852 
00853         printInDebug("--> SCardBeginTransaction\n");
00854 
00855         _lResult = SCardBeginTransaction((SCARDHANDLE)lCardHandle);
00856 
00857         if(_lResult != SCARD_S_SUCCESS)
00858         {
00859                 printInDebug("<-- SCardBeginTransaction Exception: %ld\n", _lResult);
00860                 launchException(env, _lResult);
00861                 return;
00862         }
00863         else
00864         {
00865                 printInDebug("SCardBeginTransaction success\n");
00866         }
00867         
00868         printInDebug("<-- SCardBeginTransaction\n");
00869 }
00870 
00871 JNIEXPORT void JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardEndTransaction(JNIEnv *env, jclass object, jlong lCardHandle, 
00872                                                                                                                                                                            jint iDisposition)
00873 {
00874         long _lResult;
00875 
00876         printInDebug("--> SCardEndTransaction\n");
00877 
00878         switch(iDisposition)
00879         {
00880                 case SCARD_EJECT_CARD:
00881                         printInDebug("SCardEndTransaction SCARD_EJECT_CARD\n");
00882                         break;
00883 
00884                 case SCARD_LEAVE_CARD:
00885                         printInDebug("SCardEndTransaction SCARD_LEAVE_CARD\n");
00886                         break;
00887 
00888                 case SCARD_RESET_CARD:
00889                         printInDebug("SCardEndTransaction SCARD_RESET_CARD\n");
00890                         break;
00891 
00892                 case SCARD_UNPOWER_CARD:
00893                         printInDebug("SCardEndTransaction SCARD_UNPOWER_CARD\n");
00894                         break;
00895 
00896                 default:
00897                         printInDebug("<-- SCardEndTransaction Exception: %ld\n", SCARD_E_INVALID_VALUE);
00898                         launchException(env, SCARD_E_INVALID_VALUE);
00899                         return;
00900         }
00901 
00902         _lResult = SCardEndTransaction((SCARDHANDLE)lCardHandle, iDisposition);
00903 
00904         if(_lResult != SCARD_S_SUCCESS)
00905         {
00906                 printInDebug("<-- SCardEndTransaction Exception: %ld\n", _lResult);
00907                 launchException(env, _lResult);
00908                 return;
00909         }
00910         else
00911         {
00912                 printInDebug("SCardEndTransaction success\n");
00913         }
00914         
00915         printInDebug("<-- SCardEndTransaction\n");
00916 }
00917 
00918 
00919 JNIEXPORT jbyteArray JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardControl(JNIEnv *env, jclass object, jlong lCardHandle, 
00920                                                                                                                                                                           jint iControlCode, jbyteArray pBCommand)
00921 {
00922         SCARDHANDLE     _lCardHandle = (SCARDHANDLE)lCardHandle;
00923         long            _lResult;
00924         jbyte*          _pBCommand = (env)->GetByteArrayElements(pBCommand, NULL);
00925         jint            _iLength = (env)->GetArrayLength(pBCommand);
00926         jbyte           _pBReceptionBuffer[BUFFER_MAX_SZ];
00927         jint            _iReceptionLength = BUFFER_MAX_SZ;
00928         ULONG           _ulReturnedLength = 0;
00929         jbyteArray      _objReturn = NULL;
00930 
00931     printInDebug("--> SCardControl\n");
00932 
00933     printInDebug("SCardControl controlCode: %d\n", iControlCode);
00934 
00935         if(_iLength >= 2)
00936                 printInDebug("SCardControl Length %d Command %#x %#x … %#x %#x\n", _iLength, _pBCommand[0], _pBCommand[1], _pBCommand[_iLength - 2], _pBCommand[_iLength - 1]);
00937         else
00938                 printInDebug("SCardControl Length %d\n", _iLength);
00939 
00940         _lResult = SCardControl((SCARDHANDLE)_lCardHandle, iControlCode, _pBCommand, _iLength, _pBReceptionBuffer, _iReceptionLength, &_ulReturnedLength);
00941 
00942     (env)->ReleaseByteArrayElements(pBCommand, _pBCommand, JNI_ABORT);
00943 
00944     if(_lResult != SCARD_S_SUCCESS)
00945     {
00946         printInDebug("SCardControl failed\n");
00947         printInDebug("<-- SCardControl Exception: %ld\n", _lResult);
00948         launchException(env, _lResult);
00949                 return NULL;
00950     }
00951     else
00952     {
00953         printInDebug("SCardControl success\n");
00954 
00955         if(_ulReturnedLength > 0)
00956         {
00957             printInDebug("SCardControl Length %d Response %#x %#x … %#x %#x\n", _ulReturnedLength, _pBReceptionBuffer[0], _pBReceptionBuffer[1], _pBReceptionBuffer[_ulReturnedLength - 2], _pBReceptionBuffer[_ulReturnedLength - 1]);
00958         
00959             _objReturn = (env)->NewByteArray(_ulReturnedLength);
00960             (env)->SetByteArrayRegion(_objReturn, 0, _ulReturnedLength, _pBReceptionBuffer);    
00961         }
00962         else
00963         {
00964                         printInDebug("SCardControl response empty\n");
00965         
00966             /*printInDebug("SCardControl invalid reception length\n");
00967             printInDebug("<-- SCardControl Exception: %ld\n", SCARD_E_INVALID_VALUE);
00968                         launchException(env, SCARD_E_INVALID_VALUE);
00969                         return NULL;*/
00970         }
00971     }
00972 
00973         printInDebug("<-- SCardControl\n");
00974 
00975         return _objReturn;
00976 }
00977 
00978 JNIEXPORT jbyteArray JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardReconnect(JNIEnv *env, jclass object, jlong lCardHandle, jint iShareMode, jint iPreferredProtocols, jint iInitialization)
00979 {
00980     long            _lResult;
00981     DWORD           _dwActiveProtocol;
00982     jbyteArray          _objReturn = NULL;
00983 
00984     printInDebug("--> SCardReconnect\n");
00985         
00986     switch(iShareMode)
00987     {
00988         case SCARD_SHARE_SHARED:
00989             printInDebug("SCardReconnect SCARD_SHARE_SHARED\n");
00990             break;
00991 
00992         case SCARD_SHARE_EXCLUSIVE:
00993             printInDebug("SCardReconnect SCARD_SHARE_EXCLUSIVE\n");
00994             break;
00995 
00996         default:
00997             printInDebug("SCardReconnect incorrect share mode\n");
00998             printInDebug("<-- SCardReconnect Exception: %ld\n", SCARD_E_INVALID_VALUE);
00999             launchException(env, SCARD_E_INVALID_VALUE);
01000                         return NULL;
01001     }
01002 
01003     switch(iPreferredProtocols)
01004     {
01005         case SCARD_PROTOCOL_T0:
01006             printInDebug("SCardReconnect SCARD_PROTOCOL_T0\n");
01007             break;
01008 
01009         case SCARD_PROTOCOL_T1:
01010             printInDebug("SCardReconnect SCARD_PROTOCOL_T1\n");
01011             break;
01012 
01013         case SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1:
01014             printInDebug("SCardReconnect SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1\n");
01015             break;
01016 
01017         default:
01018             printInDebug("SCardReconnect incorrect preferred protocols\n");
01019             printInDebug("<-- SCardReconnect Exception: %ld\n", SCARD_E_INVALID_VALUE);
01020             launchException(env, SCARD_E_INVALID_VALUE);
01021                         return NULL;
01022     }
01023 
01024     switch(iInitialization)
01025     {
01026         case SCARD_LEAVE_CARD:
01027             printInDebug("SCardReconnect SCARD_LEAVE_CARD nothing to do\n");
01028             break;
01029 
01030         case SCARD_RESET_CARD:
01031             printInDebug("SCardReconnect SCARD_RESET_CARD => WARM RESET\n");
01032             break;
01033 
01034         case SCARD_UNPOWER_CARD:
01035             printInDebug("SCardReconnect SCARD_UNPOWER_CARD => COLD RESET\n");
01036             break;
01037 
01038         default:
01039             printInDebug("SCardReconnect incorrect initialization type\n");
01040             printInDebug("<-- SCardReconnect Exception: %ld\n", SCARD_E_INVALID_VALUE);
01041             launchException(env, SCARD_E_INVALID_VALUE);
01042                         return NULL;
01043     }
01044 
01045     _lResult = SCardReconnect((SCARDHANDLE)lCardHandle, iShareMode, iPreferredProtocols, iInitialization, &_dwActiveProtocol);
01046 
01047     if(_lResult != SCARD_S_SUCCESS)
01048     {
01049         printInDebug("SCardReconnect failed\n");
01050         printInDebug("<-- SCardReconnect Exception: %ld\n", _lResult);
01051                 launchException(env, _lResult);
01052                 return NULL;
01053     }
01054     else
01055     {
01056         printInDebug("SCardReconnect success\n");
01057 
01058         switch(iPreferredProtocols)
01059         {
01060             case SCARD_PROTOCOL_T0:
01061                 printInDebug("SCardReconnect active protocol: SCARD_PROTOCOL_T0\n");
01062                 break;
01063 
01064             case SCARD_PROTOCOL_T1:
01065                 printInDebug("SCardReconnect active protocol: SCARD_PROTOCOL_T1\n");
01066                 break;
01067 
01068             default:
01069                 printInDebug("SCardReconnect incorrect active protocol\n");
01070                 printInDebug("<-- SCardReconnect Exception: %ld\n", SCARD_E_INVALID_VALUE);
01071                                 launchException(env, SCARD_E_INVALID_VALUE);
01072                                 return NULL;
01073         }
01074 
01075         // Get the new ATR of the card
01076                 _objReturn = Java_fr_redbilled_security_pcscforjava_PCSC_SCardGetAttrib(env, object, lCardHandle, SCARD_ATTR_ATR_STRING);
01077     }
01078 
01079     printInDebug("<-- SCardReconnect\n");
01080 
01081     return _objReturn;
01082 }
01083 
01084 JNIEXPORT jbyteArray JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardGetAttrib(JNIEnv *env, jclass object, jlong lCardHandle, 
01085                                                                                                                                                                                 jint iAttribute)
01086 {
01087         long            _lResult;
01088         BYTE*           _pBResponse = (BYTE*)malloc(sizeof(BYTE) * BUFFER_MAX_SZ);
01089         DWORD           _dwAttributeLen = BUFFER_MAX_SZ;
01090         jbyteArray  _objReturn = NULL;
01091         
01092         printInDebug("--> SCardGetAttrib\n");
01093 
01094         switch(iAttribute)
01095         {
01096                 case SCARD_ATTR_ATR_STRING:
01097                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_ATR_STRING\n");
01098                         break;
01099 
01100                 case SCARD_ATTR_CHANNEL_ID:
01101                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_CHANNEL_ID\n");
01102                         break;
01103 
01104                 case SCARD_ATTR_CHARACTERISTICS:
01105                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_CHARACTERISTICS\n");
01106                         break;
01107 
01108                 case SCARD_ATTR_CURRENT_BWT:
01109                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_CURRENT_BWT\n");
01110                         break;
01111 
01112                 case SCARD_ATTR_CURRENT_CLK:
01113                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_CURRENT_CLK\n");
01114                         break;
01115 
01116                 case SCARD_ATTR_CURRENT_CWT:
01117                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_CURRENT_CWT\n");
01118                         break;
01119 
01120                 case SCARD_ATTR_CURRENT_D:
01121                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_CURRENT_D\n");
01122                         break;
01123 
01124                 case SCARD_ATTR_CURRENT_EBC_ENCODING:
01125                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_CURRENT_EBC_ENCODING\n");
01126                         break;
01127 
01128                 case SCARD_ATTR_CURRENT_F:
01129                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_CURRENT_F\n");
01130                         break;
01131 
01132                 case SCARD_ATTR_CURRENT_IFSC:
01133                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_CURRENT_IFSC\n");
01134                         break;
01135 
01136                 case SCARD_ATTR_CURRENT_IFSD:
01137                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_CURRENT_IFSD\n");
01138                         break;
01139 
01140                 case SCARD_ATTR_CURRENT_N:
01141                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_CURRENT_N\n");
01142                         break;
01143 
01144                 case SCARD_ATTR_CURRENT_PROTOCOL_TYPE:
01145                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_CURRENT_PROTOCOL_TYPE\n");
01146                         break;
01147 
01148                 case SCARD_ATTR_CURRENT_W:
01149                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_CURRENT_W\n");
01150                         break;
01151 
01152                 case SCARD_ATTR_DEFAULT_CLK:
01153                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_DEFAULT_CLK\n");
01154                         break;
01155 
01156                 case SCARD_ATTR_DEFAULT_DATA_RATE:
01157                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_DEFAULT_DATA_RATE\n");
01158                         break;
01159 
01160                 case SCARD_ATTR_DEVICE_FRIENDLY_NAME:
01161                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_DEVICE_FRIENDLY_NAME\n");
01162                         break;
01163 
01164                 case SCARD_ATTR_DEVICE_IN_USE:
01165                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_DEVICE_IN_USE\n");
01166                         break;
01167 
01168                 case SCARD_ATTR_DEVICE_SYSTEM_NAME:
01169                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_DEVICE_SYSTEM_NAME\n");
01170                         break;
01171 
01172                 case SCARD_ATTR_DEVICE_UNIT:
01173                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_DEVICE_UNIT\n");
01174                         break;
01175 
01176                 case SCARD_ATTR_ICC_INTERFACE_STATUS:
01177                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_ICC_INTERFACE_STATUS\n");
01178                         break;
01179 
01180                 case SCARD_ATTR_ICC_PRESENCE:
01181                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_ICC_PRESENCE\n");
01182                         break;
01183 
01184                 case SCARD_ATTR_ICC_TYPE_PER_ATR:
01185                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_ICC_TYPE_PER_ATR\n");
01186                         break;
01187 
01188                 case SCARD_ATTR_MAX_CLK:
01189                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_MAX_CLK\n");
01190                         break;
01191 
01192                 case SCARD_ATTR_MAX_DATA_RATE:
01193                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_MAX_DATA_RATE\n");
01194                         break;
01195 
01196                 case SCARD_ATTR_MAX_IFSD:
01197                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_MAX_IFSD\n");
01198                         break;
01199 
01200                 case SCARD_ATTR_POWER_MGMT_SUPPORT:
01201                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_POWER_MGMT_SUPPORT\n");
01202                         break;
01203 
01204                 case SCARD_ATTR_PROTOCOL_TYPES:
01205                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_PROTOCOL_TYPES\n");
01206                         break;
01207 
01208                 case SCARD_ATTR_VENDOR_IFD_SERIAL_NO:
01209                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_VENDOR_IFD_SERIAL_NO\n");
01210                         break;
01211 
01212                 case SCARD_ATTR_VENDOR_IFD_TYPE:
01213                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_VENDOR_IFD_TYPE\n");
01214                         break;
01215 
01216                 case SCARD_ATTR_VENDOR_IFD_VERSION:
01217                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_VENDOR_IFD_VERSION\n");
01218                         break;
01219 
01220                 case SCARD_ATTR_VENDOR_NAME:
01221                         printInDebug("SCardGetAttrib attribute: SCARD_ATTR_VENDOR_NAME\n");
01222                         break;
01223 
01224                 default:
01225                         printInDebug("<-- SCardGetAttrib attribute not supported Exception: %ld\n", SCARD_E_INVALID_VALUE);
01226                         launchException(env, SCARD_E_INVALID_VALUE);
01227                         free(_pBResponse);
01228                         return NULL;
01229         }
01230 
01231         _lResult = SCardGetAttrib((SCARDHANDLE)lCardHandle, iAttribute, _pBResponse, &_dwAttributeLen);
01232 
01233         if(_lResult != SCARD_S_SUCCESS)
01234     {
01235         printInDebug("SCardGetAttrib failed\n");
01236         printInDebug("<-- SCardGetAttrib Exception: %ld\n", _lResult);
01237                 launchException(env, _lResult);
01238                 free(_pBResponse);
01239                 return NULL;
01240     }
01241     else
01242     {
01243                 printInDebug("SCardGetAttrib success\n");
01244                 
01245                 if(_dwAttributeLen > 1)
01246                         printInDebug("SCardGetAttrib length %d - %#x %#x ... %#x %#x\n", _dwAttributeLen, _pBResponse[0], _pBResponse[1], _pBResponse[_dwAttributeLen - 2], _pBResponse[_dwAttributeLen - 1]);
01247                 else
01248                         printInDebug("SCardGetAttrib length %d\n", _dwAttributeLen);
01249 
01250                 _objReturn = (env)->NewByteArray(_dwAttributeLen);
01251                 (env)->SetByteArrayRegion(_objReturn, 0, _dwAttributeLen, (jbyte*)_pBResponse);
01252         }
01253 
01254         printInDebug("<-- SCardGetAttrib\n");
01255 
01256         free(_pBResponse);
01257 
01258         return _objReturn;
01259 }
01260 
01261 JNIEXPORT void JNICALL Java_fr_redbilled_security_pcscforjava_PCSC_SCardSetAttrib(JNIEnv *env, jclass object, jlong lCardHandle, 
01262                                                                                                                                                                                 jint iAttribute, jbyteArray pBAttributeCommand)
01263 {
01264         long    _lResult;
01265         BYTE*  _pBCommand = (BYTE*)(env)->GetByteArrayElements(pBAttributeCommand, NULL);
01266         DWORD   _dwAttributeLength = (env)->GetArrayLength(pBAttributeCommand);
01267 
01268         printInDebug("--> SCardSetAttrib\n");
01269 
01270         switch(iAttribute)
01271         {
01272                 case(SCARD_ATTR_SUPRESS_T1_IFS_REQUEST):
01273                         break;
01274                 default:
01275                         printInDebug("<-- SCardSetAttrib attribute not supported Exception: %ld\n", SCARD_E_INVALID_VALUE);
01276                         launchException(env, SCARD_E_INVALID_VALUE);
01277                         break;
01278         }
01279 
01280         if(_dwAttributeLength > 1)
01281                 printInDebug("SCardSetAttrib length %d - %#x %#x ... %#x %#x\n", _dwAttributeLength, _pBCommand[0], _pBCommand[1], _pBCommand[_dwAttributeLength - 2], _pBCommand[_dwAttributeLength - 1]);
01282         else
01283                 printInDebug("SCardSetAttrib length %d\n", _dwAttributeLength);
01284 
01285         _lResult = SCardSetAttrib((SCARDHANDLE)lCardHandle, iAttribute, _pBCommand, _dwAttributeLength);
01286 
01287         (env)->ReleaseByteArrayElements(pBAttributeCommand, (jbyte*)_pBCommand, JNI_ABORT);
01288 
01289         if(_lResult != SCARD_S_SUCCESS)
01290     {
01291         printInDebug("SCardSetAttrib failed\n");
01292         printInDebug("<-- SCardSetAttrib Exception: %ld\n", _lResult);
01293                 launchException(env, _lResult);
01294                 return;
01295     }
01296     else
01297     {
01298                 printInDebug("SCardSetAttrib success\n");
01299         }
01300 
01301         printInDebug("<-- SCardSetAttrib\n");
01302 }
01303 
01304 void printInDebug(const char * format, ...)
01305 {
01306         #if(defined _DEBUG)
01307                 va_list _arguments;
01308                 time_t  _time;
01309                 char _hour[32];
01310                 int _idRead = 0, _idWrite = 0;
01311                 
01312                 // open the debug file
01313                 FILE * _file;
01314                 fopen_s(&_file, "c:\\debugPCSCJNI.log", "a+");
01315                 
01316                 va_start(_arguments, format);
01317                 time(&_time);
01318                 ctime_s(_hour, sizeof(_hour) ,&_time);
01319                 
01320                 while (_hour[_idRead] != '\0')
01321                 {
01322                         if (_hour[_idRead] != '\n')
01323                         {
01324                                 _hour[_idWrite] = _hour[_idRead];
01325                                 _idWrite++;
01326                         }
01327                         _idRead++;
01328                 }
01329                 _hour[_idWrite] = '\0';
01330 
01331                 fputs(_hour, _file);
01332                 fputs(" :: ", _file);
01333                 vfprintf(_file, format, _arguments);
01334                 
01335                 // close the debug file
01336                 fclose(_file);          
01337         #endif
01338 }
01339 
01340 void launchException(JNIEnv * env, long lException)
01341 {
01342         jclass          _pcscClass;
01343     jmethodID   _constructor;
01344     jthrowable  _pcscException;
01345 
01346     _pcscClass = env->FindClass(PCSC_EXCEPTION_CLASS);
01347     _constructor = env->GetMethodID(_pcscClass, "<init>", "(I)V");
01348     
01349         _pcscException = (jthrowable) env->NewObject(_pcscClass, _constructor, lException);
01350         
01351         env->Throw(_pcscException);
01352 }
01353