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