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