PCSC4Java
0.2
Library PCSC for Java language.
|
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 }