rev 12879 : 8136556: Add the ability to perform static builds of MacOSX x64 binaries
Reviewed-by: ihse, bdelsart, gadams, lfoltan, rriggs, hseigel, twisti

   1 /*
   2  * Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 /* disable asserts in product mode */
  27 #ifndef DEBUG
  28   #ifndef NDEBUG
  29     #define NDEBUG
  30   #endif
  31 #endif
  32 
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <assert.h>
  37 
  38 #include <winscard.h>
  39 
  40 // #define J2PCSC_DEBUG
  41 
  42 #ifdef J2PCSC_DEBUG
  43 #define dprintf(s) printf(s)
  44 #define dprintf1(s, p1) printf(s, p1)
  45 #define dprintf2(s, p1, p2) printf(s, p1, p2)
  46 #define dprintf3(s, p1, p2, p3) printf(s, p1, p2, p3)
  47 #else
  48 #define dprintf(s)
  49 #define dprintf1(s, p1)
  50 #define dprintf2(s, p1, p2)
  51 #define dprintf3(s, p1, p2, p3)
  52 #endif
  53 
  54 #include "sun_security_smartcardio_PCSC.h"
  55 
  56 #include "pcsc_md.h"
  57 


  58 #define MAX_STACK_BUFFER_SIZE 8192
  59 
  60 // make the buffers larger than what should be necessary, just in case
  61 #define ATR_BUFFER_SIZE 128
  62 #define READERNAME_BUFFER_SIZE 128
  63 #define RECEIVE_BUFFER_SIZE MAX_STACK_BUFFER_SIZE
  64 
  65 #define J2PCSC_EXCEPTION_NAME "sun/security/smartcardio/PCSCException"
  66 
  67 void throwOutOfMemoryError(JNIEnv *env, const char *msg) {
  68     jclass cls = (*env)->FindClass(env, "java/lang/OutOfMemoryError");
  69 
  70     if (cls != NULL) /* Otherwise an exception has already been thrown */
  71         (*env)->ThrowNew(env, cls, msg);
  72 
  73 }
  74 
  75 void throwPCSCException(JNIEnv* env, LONG code) {
  76     jclass pcscClass;
  77     jmethodID constructor;
  78     jthrowable pcscException;
  79 
  80     pcscClass = (*env)->FindClass(env, J2PCSC_EXCEPTION_NAME);
  81     if (pcscClass == NULL) {
  82         return;
  83     }
  84     constructor = (*env)->GetMethodID(env, pcscClass, "<init>", "(I)V");
  85     if (constructor == NULL) {
  86         return;
  87     }
  88     pcscException = (jthrowable) (*env)->NewObject(env, pcscClass,
  89         constructor, (jint)code);
  90     if (pcscException != NULL) {
  91         (*env)->Throw(env, pcscException);
  92     }
  93 }
  94 
  95 jboolean handleRV(JNIEnv* env, LONG code) {
  96     if (code == SCARD_S_SUCCESS) {
  97         return JNI_FALSE;
  98     } else {
  99         throwPCSCException(env, code);
 100         return JNI_TRUE;
 101     }
 102 }
 103 
 104 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
 105     return JNI_VERSION_1_4;
 106 }
 107 
 108 JNIEXPORT jlong JNICALL Java_sun_security_smartcardio_PCSC_SCardEstablishContext
 109     (JNIEnv *env, jclass thisClass, jint dwScope)
 110 {
 111     SCARDCONTEXT context = 0;
 112     LONG rv;
 113     dprintf("-establishContext\n");
 114     rv = CALL_SCardEstablishContext(dwScope, NULL, NULL, &context);
 115     if (handleRV(env, rv)) {
 116         return 0;
 117     }
 118     // note: SCARDCONTEXT is typedef'd as long, so this works
 119     return (jlong)context;
 120 }
 121 
 122 /**
 123  * Convert a multi string to a java string array,
 124  */
 125 jobjectArray pcsc_multi2jstring(JNIEnv *env, char *spec) {
 126     jobjectArray result;
 127     jclass stringClass;
 128     char *cp, **tab = NULL;
 129     jstring js;
 130     int cnt = 0;
 131 
 132     cp = spec;
 133     while (*cp != 0) {
 134         cp += (strlen(cp) + 1);
 135         ++cnt;
 136     }
 137 
 138     tab = (char **)malloc(cnt * sizeof(char *));
 139     if (tab == NULL) {
 140         throwOutOfMemoryError(env, NULL);
 141         return NULL;
 142     }
 143 
 144     cnt = 0;
 145     cp = spec;
 146     while (*cp != 0) {
 147         tab[cnt++] = cp;
 148         cp += (strlen(cp) + 1);
 149     }
 150 
 151     stringClass = (*env)->FindClass(env, "java/lang/String");
 152     if (stringClass == NULL) {
 153         free(tab);
 154         return NULL;
 155     }
 156 
 157     result = (*env)->NewObjectArray(env, cnt, stringClass, NULL);
 158     if (result != NULL) {
 159         while (cnt-- > 0) {
 160             js = (*env)->NewStringUTF(env, tab[cnt]);
 161             if ((*env)->ExceptionCheck(env)) {
 162                 free(tab);
 163                 return NULL;
 164             }
 165             (*env)->SetObjectArrayElement(env, result, cnt, js);
 166             if ((*env)->ExceptionCheck(env)) {
 167                 free(tab);
 168                 return NULL;
 169             }
 170             (*env)->DeleteLocalRef(env, js);
 171         }
 172     }
 173     free(tab);
 174     return result;
 175 }
 176 
 177 JNIEXPORT jobjectArray JNICALL Java_sun_security_smartcardio_PCSC_SCardListReaders
 178     (JNIEnv *env, jclass thisClass, jlong jContext)
 179 {
 180     SCARDCONTEXT context = (SCARDCONTEXT)jContext;
 181     LONG rv;
 182     LPTSTR mszReaders = NULL;
 183     DWORD size = 0;
 184     jobjectArray result;
 185 
 186     dprintf1("-context: %x\n", context);
 187     rv = CALL_SCardListReaders(context, NULL, NULL, &size);
 188     if (handleRV(env, rv)) {
 189         return NULL;
 190     }
 191     dprintf1("-size: %d\n", size);
 192 
 193     if (size) {
 194         mszReaders = malloc(size);
 195         if (mszReaders == NULL) {
 196             throwOutOfMemoryError(env, NULL);
 197             return NULL;
 198         }
 199 
 200         rv = CALL_SCardListReaders(context, NULL, mszReaders, &size);
 201         if (handleRV(env, rv)) {
 202             free(mszReaders);
 203             return NULL;
 204         }
 205         dprintf1("-String: %s\n", mszReaders);
 206     }
 207 
 208     result = pcsc_multi2jstring(env, mszReaders);
 209     free(mszReaders);
 210     return result;
 211 }
 212 
 213 JNIEXPORT jlong JNICALL Java_sun_security_smartcardio_PCSC_SCardConnect
 214     (JNIEnv *env, jclass thisClass, jlong jContext, jstring jReaderName,
 215     jint jShareMode, jint jPreferredProtocols)
 216 {
 217     SCARDCONTEXT context = (SCARDCONTEXT)jContext;
 218     LONG rv;
 219     LPCTSTR readerName;
 220     SCARDHANDLE card = 0;
 221     DWORD proto = 0;
 222 
 223     readerName = (*env)->GetStringUTFChars(env, jReaderName, NULL);
 224     if (readerName == NULL) {
 225         return 0;
 226     }
 227     rv = CALL_SCardConnect(context, readerName, jShareMode, jPreferredProtocols, &card, &proto);
 228     (*env)->ReleaseStringUTFChars(env, jReaderName, readerName);
 229     dprintf1("-cardhandle: %x\n", card);
 230     dprintf1("-protocol: %d\n", proto);
 231     if (handleRV(env, rv)) {
 232         return 0;
 233     }
 234 
 235     return (jlong)card;
 236 }
 237 
 238 JNIEXPORT jbyteArray JNICALL Java_sun_security_smartcardio_PCSC_SCardTransmit
 239     (JNIEnv *env, jclass thisClass, jlong jCard, jint protocol,
 240     jbyteArray jBuf, jint jOfs, jint jLen)
 241 {
 242     SCARDHANDLE card = (SCARDHANDLE)jCard;
 243     LONG rv;
 244     SCARD_IO_REQUEST sendPci;
 245     unsigned char *sbuf;
 246     unsigned char rbuf[RECEIVE_BUFFER_SIZE];
 247     DWORD rlen = RECEIVE_BUFFER_SIZE;
 248     int ofs = (int)jOfs;
 249     int len = (int)jLen;
 250     jbyteArray jOut;
 251 
 252     sendPci.dwProtocol = protocol;
 253     sendPci.cbPciLength = sizeof(SCARD_IO_REQUEST);
 254 
 255     sbuf = (unsigned char *) ((*env)->GetByteArrayElements(env, jBuf, NULL));
 256     if (sbuf == NULL) {
 257         return NULL;
 258     }
 259     rv = CALL_SCardTransmit(card, &sendPci, sbuf + ofs, len, NULL, rbuf, &rlen);
 260     (*env)->ReleaseByteArrayElements(env, jBuf, (jbyte *)sbuf, JNI_ABORT);
 261 
 262     if (handleRV(env, rv)) {
 263         return NULL;
 264     }
 265 
 266     jOut = (*env)->NewByteArray(env, rlen);
 267     if (jOut != NULL) {
 268         (*env)->SetByteArrayRegion(env, jOut, 0, rlen, (jbyte *)rbuf);
 269         if ((*env)->ExceptionCheck(env)) {
 270             return NULL;
 271         }
 272     }
 273     return jOut;
 274 }
 275 
 276 JNIEXPORT jbyteArray JNICALL Java_sun_security_smartcardio_PCSC_SCardStatus
 277     (JNIEnv *env, jclass thisClass, jlong jCard, jbyteArray jStatus)
 278 {
 279     SCARDHANDLE card = (SCARDHANDLE)jCard;
 280     LONG rv;
 281     char readerName[READERNAME_BUFFER_SIZE];
 282     DWORD readerLen = READERNAME_BUFFER_SIZE;
 283     unsigned char atr[ATR_BUFFER_SIZE];
 284     DWORD atrLen = ATR_BUFFER_SIZE;
 285     DWORD state = 0;
 286     DWORD protocol = 0;
 287     jbyteArray jArray;
 288     jbyte status[2];
 289 
 290     rv = CALL_SCardStatus(card, readerName, &readerLen, &state, &protocol, atr, &atrLen);
 291     if (handleRV(env, rv)) {
 292         return NULL;
 293     }
 294     dprintf1("-reader: %s\n", readerName);
 295     dprintf1("-status: %d\n", state);
 296     dprintf1("-protocol: %d\n", protocol);
 297 
 298     jArray = (*env)->NewByteArray(env, atrLen);
 299     if (jArray == NULL) {
 300         return NULL;
 301     }
 302     (*env)->SetByteArrayRegion(env, jArray, 0, atrLen, (jbyte *)atr);
 303     if ((*env)->ExceptionCheck(env)) {
 304         return NULL;
 305     }
 306     status[0] = (jbyte) state;
 307     status[1] = (jbyte) protocol;
 308     (*env)->SetByteArrayRegion(env, jStatus, 0, 2, status);
 309     if ((*env)->ExceptionCheck(env)) {
 310         return NULL;
 311     }
 312     return jArray;
 313 }
 314 
 315 JNIEXPORT void JNICALL Java_sun_security_smartcardio_PCSC_SCardDisconnect
 316     (JNIEnv *env, jclass thisClass, jlong jCard, jint jDisposition)
 317 {
 318     SCARDHANDLE card = (SCARDHANDLE)jCard;
 319     LONG rv;
 320 
 321     rv = CALL_SCardDisconnect(card, jDisposition);
 322     dprintf1("-disconnect: 0x%X\n", rv);
 323     handleRV(env, rv);
 324     return;
 325 }
 326 
 327 JNIEXPORT jintArray JNICALL Java_sun_security_smartcardio_PCSC_SCardGetStatusChange
 328     (JNIEnv *env, jclass thisClass, jlong jContext, jlong jTimeout,
 329     jintArray jCurrentState, jobjectArray jReaderNames)
 330 {
 331     SCARDCONTEXT context = (SCARDCONTEXT)jContext;
 332     LONG rv;
 333     int readers = (*env)->GetArrayLength(env, jReaderNames);
 334     SCARD_READERSTATE *readerState;
 335     int i;
 336     jintArray jEventState = NULL;
 337     int *currentState = NULL;
 338     const char *readerName;
 339 
 340     readerState = calloc(readers, sizeof(SCARD_READERSTATE));
 341     if (readerState == NULL && readers > 0) {
 342         throwOutOfMemoryError(env, NULL);
 343         return NULL;
 344     }
 345 
 346     currentState = (*env)->GetIntArrayElements(env, jCurrentState, NULL);
 347     if (currentState == NULL) {
 348         free(readerState);
 349         return NULL;
 350     }
 351 
 352     for (i = 0; i < readers; i++) {
 353         readerState[i].szReader = NULL;
 354     }
 355 
 356     for (i = 0; i < readers; i++) {
 357         jobject jReaderName = (*env)->GetObjectArrayElement(env, jReaderNames, i);
 358         if ((*env)->ExceptionCheck(env)) {
 359             goto cleanup;
 360         }
 361         readerName = (*env)->GetStringUTFChars(env, jReaderName, NULL);
 362         if (readerName == NULL) {
 363             goto cleanup;
 364         }
 365         readerState[i].szReader = strdup(readerName);
 366         (*env)->ReleaseStringUTFChars(env, jReaderName, readerName);
 367         if (readerState[i].szReader == NULL) {
 368             throwOutOfMemoryError(env, NULL);
 369             goto cleanup;
 370         }
 371         readerState[i].pvUserData = NULL;
 372         readerState[i].dwCurrentState = currentState[i];
 373         readerState[i].dwEventState = SCARD_STATE_UNAWARE;
 374         readerState[i].cbAtr = 0;
 375         (*env)->DeleteLocalRef(env, jReaderName);
 376     }
 377 
 378     if (readers > 0) {
 379         rv = CALL_SCardGetStatusChange(context, (DWORD)jTimeout, readerState, readers);
 380         if (handleRV(env, rv)) {
 381             goto cleanup;
 382         }
 383     }
 384 
 385     jEventState = (*env)->NewIntArray(env, readers);
 386     if (jEventState == NULL) {
 387         goto cleanup;
 388     }
 389     for (i = 0; i < readers; i++) {
 390         jint eventStateTmp;
 391         dprintf3("-reader status %s: 0x%X, 0x%X\n", readerState[i].szReader,
 392             readerState[i].dwCurrentState, readerState[i].dwEventState);
 393         eventStateTmp = (jint)readerState[i].dwEventState;
 394         (*env)->SetIntArrayRegion(env, jEventState, i, 1, &eventStateTmp);
 395         if ((*env)->ExceptionCheck(env)) {
 396             jEventState = NULL;
 397             goto cleanup;
 398         }
 399     }
 400 cleanup:
 401     (*env)->ReleaseIntArrayElements(env, jCurrentState, currentState, JNI_ABORT);
 402     for (i = 0; i < readers; i++) {
 403         free((char *)readerState[i].szReader);
 404     }
 405     free(readerState);
 406     return jEventState;
 407 }
 408 
 409 JNIEXPORT void JNICALL Java_sun_security_smartcardio_PCSC_SCardBeginTransaction
 410     (JNIEnv *env, jclass thisClass, jlong jCard)
 411 {
 412     SCARDHANDLE card = (SCARDHANDLE)jCard;
 413     LONG rv;
 414 
 415     rv = CALL_SCardBeginTransaction(card);
 416     dprintf1("-beginTransaction: 0x%X\n", rv);
 417     handleRV(env, rv);
 418     return;
 419 }
 420 
 421 JNIEXPORT void JNICALL Java_sun_security_smartcardio_PCSC_SCardEndTransaction
 422     (JNIEnv *env, jclass thisClass, jlong jCard, jint jDisposition)
 423 {
 424     SCARDHANDLE card = (SCARDHANDLE)jCard;
 425     LONG rv;
 426 
 427     rv = CALL_SCardEndTransaction(card, jDisposition);
 428     dprintf1("-endTransaction: 0x%X\n", rv);
 429     handleRV(env, rv);
 430     return;
 431 }
 432 
 433 JNIEXPORT jbyteArray JNICALL Java_sun_security_smartcardio_PCSC_SCardControl
 434     (JNIEnv *env, jclass thisClass, jlong jCard, jint jControlCode, jbyteArray jSendBuffer)
 435 {
 436     SCARDHANDLE card = (SCARDHANDLE)jCard;
 437     LONG rv;
 438     jbyte* sendBuffer;
 439     jint sendBufferLength = (*env)->GetArrayLength(env, jSendBuffer);
 440     jbyte receiveBuffer[MAX_STACK_BUFFER_SIZE];
 441     jint receiveBufferLength = MAX_STACK_BUFFER_SIZE;
 442     ULONG returnedLength = 0;
 443     jbyteArray jReceiveBuffer;
 444 
 445     sendBuffer = (*env)->GetByteArrayElements(env, jSendBuffer, NULL);
 446     if (sendBuffer == NULL) {
 447         return NULL;
 448     }
 449 
 450 #ifdef J2PCSC_DEBUG
 451 {
 452     int k;
 453     printf("-control: 0x%X\n", jControlCode);
 454     printf("-send: ");
 455     for (k = 0; k < sendBufferLength; k++) {
 456         printf("%02x ", sendBuffer[k]);
 457     }
 458     printf("\n");
 459 }
 460 #endif
 461 
 462     rv = CALL_SCardControl(card, jControlCode, sendBuffer, sendBufferLength,
 463         receiveBuffer, receiveBufferLength, &returnedLength);
 464 
 465     (*env)->ReleaseByteArrayElements(env, jSendBuffer, sendBuffer, JNI_ABORT);
 466     if (handleRV(env, rv)) {
 467         return NULL;
 468     }
 469 
 470 #ifdef J2PCSC_DEBUG
 471 {
 472     int k;
 473     printf("-recv:  ");
 474     for (k = 0; k < returnedLength; k++) {
 475         printf("%02x ", receiveBuffer[k]);
 476     }
 477     printf("\n");
 478 }
 479 #endif
 480 
 481     jReceiveBuffer = (*env)->NewByteArray(env, returnedLength);
 482     if (jReceiveBuffer == NULL) {
 483         return NULL;
 484     }
 485     (*env)->SetByteArrayRegion(env, jReceiveBuffer, 0, returnedLength, receiveBuffer);
 486     if ((*env)->ExceptionCheck(env)) {
 487         return NULL;
 488     }
 489     return jReceiveBuffer;
 490 }
--- EOF ---