Home | History | Annotate | Download | only in jni 
      1 /*
      2  * Copyright (C) 2007 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 /**
     18  * @file drm1_jni.c
     19  *
     20  * This file implement the Java Native Interface
     21  * for supporting OMA DRM 1.0
     22  */
     23 
     24 #include <jni/drm1_jni.h>
     25 #include <objmng/svc_drm.h>
     26 #include "log.h"
     27 
     28 
     29 #define MS_PER_SECOND 1000                  /* Milliseconds per second */
     30 #define MS_PER_MINUTE 60 * MS_PER_SECOND    /* Milliseconds per minute */
     31 #define MS_PER_HOUR   60 * MS_PER_MINUTE    /* Milliseconds per hour */
     32 #define MS_PER_DAY    24 * MS_PER_HOUR      /* Milliseconds per day */
     33 
     34 #define SECONDS_PER_MINUTE 60                       /* Seconds per minute*/
     35 #define SECONDS_PER_HOUR   60 * SECONDS_PER_MINUTE  /* Seconds per hour */
     36 #define SECONDS_PER_DAY    24 * SECONDS_PER_HOUR    /* Seconds per day */
     37 
     38 #define DAY_PER_MONTH 30                    /* Days per month */
     39 #define DAY_PER_YEAR  365                   /* Days per year */
     40 
     41 /** Nonzero if 'y' is a leap year, else zero. */
     42 #define leap(y) (((y) % 4 == 0 && (y) % 100 != 0) || (y) % 400 == 0)
     43 
     44 /** Number of leap years from 1970 to 'y' (not including 'y' itself). */
     45 #define nleap(y) (((y) - 1969) / 4 - ((y) - 1901) / 100 + ((y) - 1601) / 400)
     46 
     47 /** Accumulated number of days from 01-Jan up to start of current month. */
     48 static const int32_t ydays[] = {
     49     0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
     50 };
     51 
     52 #define int64_const(s)          (s)
     53 #define int64_add(dst, s1, s2)  ((void)((dst) = (s1) + (s2)))
     54 #define int64_mul(dst, s1, s2)  ((void)((dst) = (int64_t)(s1) * (int64_t)(s2)))
     55 
     56 /**
     57  * DRM data structure
     58  */
     59 typedef struct _DrmData {
     60     /**
     61      * The id of the DRM content.
     62      */
     63     int32_t id;
     64 
     65     /**
     66      * The pointer of JNI interface.
     67      */
     68     JNIEnv* env;
     69 
     70     /**
     71      * The pointer of DRM raw content InputStream object.
     72      */
     73     jobject* pInData;
     74 
     75     /**
     76      * The len of the InputStream object.
     77      */
     78     int32_t len;
     79 
     80     /**
     81      * The next DRM data.
     82      */
     83     struct _DrmData *next;
     84 } DrmData;
     85 
     86 /** The table to hold all the DRM data. */
     87 static DrmData *drmTable = NULL;
     88 
     89 /**
     90  * Allocate a new item of DrmData.
     91  *
     92  * \return a pointer to a DrmData item if allocate successfully,
     93  *         otherwise return NULL
     94  */
     95 static DrmData * newItem(void)
     96 {
     97     DrmData *d = (DrmData *)malloc(sizeof(DrmData));
     98 
     99     if (d != NULL) {
    100         d->id = -1;
    101         d->next = NULL;
    102     }
    103 
    104     return d;
    105 }
    106 
    107 /**
    108  * Free the memory of the specified DrmData item <code>d</code>.
    109  *
    110  * \param d - a pointer to DrmData
    111  */
    112 static void freeItem(DrmData *d)
    113 {
    114     assert(d != NULL);
    115 
    116     free(d);
    117 }
    118 
    119 /**
    120  * Insert a DrmData item with given <code>name</code> into the head of
    121  * the DrmData list.
    122  *
    123  * @param d - the pointer of the JNI interface
    124  * @param pInData - the pointer of the DRM content InputStream object.
    125  *
    126  * @return <code>JNI_DRM_SUCCESS</code> if insert successfully, otherwise
    127  *         return <code>JNI_DRM_FAILURE</code>
    128  */
    129 static int32_t addItem(DrmData* d)
    130 {
    131     if (NULL == d)
    132         return JNI_DRM_FAILURE;
    133 
    134     if (NULL == drmTable) {
    135         drmTable = d;
    136         return JNI_DRM_SUCCESS;
    137     }
    138 
    139     d->next = drmTable;
    140     drmTable = d;
    141 
    142     return JNI_DRM_SUCCESS;
    143 }
    144 
    145 /**
    146  * Get the item from the DrmData list by the specified <code>
    147  * id</code>.
    148  *
    149  * @param p - the pointer of the DRM content InputStream object.
    150  *
    151  * @return a pointer to the DrmData item if find it successfuly,
    152  *         otherwise return NULL
    153  */
    154 static DrmData * getItem(int32_t id)
    155 {
    156     DrmData *d;
    157 
    158     if (NULL == drmTable)
    159         return NULL;
    160 
    161     for (d = drmTable; d != NULL; d = d->next) {
    162         if (id == d->id)
    163             return d;
    164     }
    165 
    166     return NULL;
    167 }
    168 
    169 /**
    170  * Remove the specified DrmData item <code>d</code>.
    171  *
    172  * @param p - the pointer of the DRM content InputStream object.
    173  *
    174  * @return <code>JNI_DRM_SUCCESS</code> if remove successfuly,
    175  *         otherwise return <code>JNI_DRM_FAILURE</code>
    176  */
    177 static int32_t removeItem(int32_t id)
    178 {
    179     DrmData *curItem, *preItem, *dstItem;
    180 
    181     if (NULL == drmTable)
    182         return JNI_DRM_FAILURE;
    183 
    184     preItem = NULL;
    185     for (curItem = drmTable; curItem != NULL; curItem = curItem->next) {
    186         if (id == curItem->id) {
    187             if (curItem == drmTable)
    188                 drmTable = curItem->next;
    189             else
    190                 preItem->next = curItem->next;
    191 
    192             freeItem(curItem);
    193 
    194             return JNI_DRM_SUCCESS;
    195         }
    196 
    197         preItem = curItem;
    198     }
    199 
    200     return JNI_DRM_FAILURE;
    201 }
    202 
    203 
    204 static int32_t getInputStreamDataLength(int32_t handle)
    205 {
    206     JNIEnv* env;
    207     jobject* pInputStream;
    208     int32_t len;
    209     DrmData* p;
    210     jclass cls;
    211     jmethodID mid;
    212 
    213     p = (DrmData *)handle;
    214 
    215     if (NULL == p)
    216         return 0;
    217 
    218     env = p->env;
    219     pInputStream = p->pInData;
    220     len = p->len;
    221 
    222     if (NULL == env || p->len <= 0 || NULL == pInputStream)
    223         return 0;
    224 
    225     /* check the original InputStream is available or not */
    226     cls = (*env)->GetObjectClass(env, *pInputStream);
    227     mid = (*env)->GetMethodID(env, cls, "available", "()I");
    228     (*env)->DeleteLocalRef(env, cls);
    229 
    230     if (NULL == mid)
    231         return 0;
    232 
    233     if (0 > (*env)->CallIntMethod(env, *pInputStream, mid))
    234         return 0;
    235 
    236     return len;
    237 }
    238 
    239 static int32_t readInputStreamData(int32_t handle, uint8_t* buf, int32_t bufLen)
    240 {
    241     JNIEnv* env;
    242     jobject* pInputStream;
    243     int32_t len;
    244     DrmData* p;
    245     jclass cls;
    246     jmethodID mid;
    247     jbyteArray tmp;
    248     int tmpLen;
    249     jbyte* pNativeBuf;
    250 
    251     p = (DrmData *)handle;
    252 
    253     if (NULL == p || NULL == buf || bufLen <- 0)
    254         return 0;
    255 
    256     env = p->env;
    257     pInputStream = p->pInData;
    258     len = p->len;
    259 
    260     if (NULL == env || p->len <= 0 || NULL == pInputStream)
    261         return 0;
    262 
    263     cls = (*env)->GetObjectClass(env, *pInputStream);
    264     mid = (*env)->GetMethodID(env, cls, "read", "([BII)I");
    265     tmp = (*env)->NewByteArray(env, bufLen);
    266     bufLen = (*env)->CallIntMethod(env, *pInputStream, mid, tmp, 0, bufLen);
    267 
    268     (*env)->DeleteLocalRef(env, cls);
    269 
    270     if (-1 == bufLen)
    271         return -1;
    272 
    273     pNativeBuf = (*env)->GetByteArrayElements(env, tmp, NULL);
    274     memcpy(buf, pNativeBuf, bufLen);
    275     (*env)->ReleaseByteArrayElements(env, tmp, pNativeBuf, 0);
    276     (*env)->DeleteLocalRef(env, tmp);
    277 
    278     return bufLen;
    279 }
    280 
    281 static const T_DRM_Rights_Info_Node *searchRightsObject(const jbyte* roId, const T_DRM_Rights_Info_Node* pRightsList)
    282 {
    283     const T_DRM_Rights_Info_Node *pTmp;
    284 
    285     if (NULL == roId || NULL == pRightsList)
    286         return NULL;
    287 
    288     pTmp = pRightsList;
    289 
    290     while (NULL != pTmp) {
    291         if(0 == strcmp((char *)roId, (char *)pTmp->roInfo.roId))
    292             break;
    293         pTmp = pTmp->next;
    294     }
    295 
    296     return pTmp;
    297 }
    298 
    299 /**
    300  * Returns the difference in seconds between the given GMT time
    301  * and 1970-01-01 00:00:00 GMT.
    302  *
    303  * \param year the year (since 1970)
    304  * \param month the month (1 - 12)
    305  * \param day the day (1 - 31)
    306  * \param hour the hour (0 - 23)
    307  * \param minute the minute (0 - 59)
    308  * \param second the second (0 - 59)
    309  *
    310  * \return the difference in seconds between the given GMT time
    311  *         and 1970-01-01 00:00:00 GMT.
    312  */
    313 static int64_t mkgmtime(
    314         uint32_t year, uint32_t month, uint32_t day,
    315         uint32_t hour, uint32_t minute, uint32_t second)
    316 {
    317     int64_t result;
    318 
    319     /*
    320      * FIXME: It does not check whether the specified days
    321      *        is valid based on the specified months.
    322      */
    323     assert(year >= 1970
    324             && month > 0 && month <= 12
    325             && day > 0 && day <= 31
    326             && hour < 24 && minute < 60
    327             && second < 60);
    328 
    329     /* Set 'day' to the number of days into the year. */
    330     day += ydays[month - 1] + (month > 2 && leap (year)) - 1;
    331 
    332     /* Now calculate 'day' to the number of days since Jan 1, 1970. */
    333     day = day + 365 * (year - 1970) + nleap(year);
    334 
    335     int64_mul(result, int64_const(day), int64_const(SECONDS_PER_DAY));
    336     int64_add(result, result, int64_const(
    337         SECONDS_PER_HOUR * hour + SECONDS_PER_MINUTE * minute + second));
    338 
    339     return result;
    340 }
    341 
    342 /**
    343  * Compute the milliseconds by the specified <code>date</code>
    344  * and <code>time</code>.
    345  *
    346  * @param date - the specified date,
    347  *               <code>date = year * 10000 + month * 100 + day</code>
    348  * @param time - the specified time,
    349  *               <code>time = hour * 10000 + minute * 100 + second</code>
    350  *
    351  * @return the related milliseconds
    352  */
    353 static int64_t computeTime(int32_t date, int32_t time)
    354 {
    355     int32_t year, month, day, hour, minute, second;
    356 
    357     year = date / 10000;
    358     month = (date / 100) % 100;
    359     day = date % 100;
    360     hour = time / 10000;
    361     minute = (time / 100) % 100;
    362     second = time % 100;
    363 
    364     /* Adjust the invalid parameters. */
    365     if (year < 1970) year = 1970;
    366     if (month < 1) month = 1;
    367     if (month > 12) month = 12;
    368     if (day < 1) day = 1;
    369     if (day > 31) day = 31;
    370     if (hour < 0) hour = 0;
    371     if (hour > 23) hour = 23;
    372     if (minute < 0) minute = 0;
    373     if (minute > 59) minute = 59;
    374     if (second < 0) second = 0;
    375     if (second > 59) second = 59;
    376 
    377     return mkgmtime(year, month, day, hour, minute, second) * 1000;
    378 }
    379 
    380 /**
    381  * Compute the milliseconds by the specified <code>date</code>
    382  * and <code>time</code>.
    383  * Note that here we always treat 1 year as 365 days and 1 month as 30 days
    384  * that is not precise. But it should not be a problem since OMA DRM 2.0
    385  * already restricts the interval representation to be day-based,
    386  * i.e. there will not be an interval with year or month any more in the
    387  * future.
    388  *
    389  * @param date - the specified date,
    390  *               <code>date = year * 10000 + month * 100 + day</code>
    391  * @param time - the specified time,
    392  *               <code>time = hour * 10000 + minute * 100 + second</code>
    393  *
    394  * @return the related milliseconds
    395  */
    396 static int64_t computeInterval(int32_t date, int32_t time)
    397 {
    398     int32_t year, month, day, hour, minute, second;
    399     int64_t milliseconds;
    400 
    401     year = date / 10000;
    402     month = (date / 100) % 100;
    403     day = date % 100;
    404     hour = time / 10000;
    405     minute = (time / 100) % 100;
    406     second = time % 100;
    407 
    408     /* milliseconds = ((((year * 365 + month * 30 + day) * 24
    409      *                + hour) * 60 + minute) * 60 + second) * 1000;
    410      */
    411     int64_mul(milliseconds,
    412         int64_const(year * DAY_PER_YEAR + month * DAY_PER_MONTH + day),
    413         int64_const(MS_PER_DAY));
    414     int64_add(milliseconds, milliseconds,
    415         int64_const(hour * MS_PER_HOUR + minute * MS_PER_MINUTE +
    416             second * MS_PER_SECOND));
    417 
    418     return milliseconds;
    419 }
    420 
    421 static jint getObjectIntField(JNIEnv * env, jobject obj, const char *name, jint * value)
    422 {
    423     jclass clazz;
    424     jfieldID field;
    425 
    426     clazz = (*env)->GetObjectClass(env, obj);
    427     if (NULL == clazz)
    428         return JNI_DRM_FAILURE;
    429 
    430     field = (*env)->GetFieldID(env, clazz, name, "I");
    431     (*env)->DeleteLocalRef(env, clazz);
    432 
    433     if (NULL == field)
    434         return JNI_DRM_FAILURE;
    435 
    436     *value = (*env)->GetIntField(env, obj, field);
    437 
    438     return JNI_DRM_SUCCESS;
    439 }
    440 
    441 static jint setObjectIntField(JNIEnv * env, jobject obj, const char *name, jint value)
    442 {
    443     jclass clazz;
    444     jfieldID field;
    445 
    446     clazz = (*env)->GetObjectClass(env, obj);
    447     if (NULL == clazz)
    448         return JNI_DRM_FAILURE;
    449 
    450     field = (*env)->GetFieldID(env, clazz, name, "I");
    451     (*env)->DeleteLocalRef(env, clazz);
    452 
    453     if (NULL == field)
    454         return JNI_DRM_FAILURE;
    455 
    456     (*env)->SetIntField(env, obj, field, value);
    457 
    458     return JNI_DRM_SUCCESS;
    459 }
    460 
    461 static jint setObjectLongField(JNIEnv * env, jobject obj, const char *name, jlong value)
    462 {
    463     jclass clazz;
    464     jfieldID field;
    465 
    466     clazz = (*env)->GetObjectClass(env, obj);
    467     if (NULL == clazz)
    468         return JNI_DRM_FAILURE;
    469 
    470     field = (*env)->GetFieldID(env, clazz, name, "J");
    471     (*env)->DeleteLocalRef(env, clazz);
    472 
    473     if (NULL == field)
    474         return JNI_DRM_FAILURE;
    475 
    476     (*env)->SetLongField(env, obj, field, value);
    477 
    478     return JNI_DRM_SUCCESS;
    479 }
    480 
    481 static jint setConstraintFields(JNIEnv * env, jobject constraint, T_DRM_Constraint_Info * pConstraint)
    482 {
    483     /* if no this permission */
    484     if (pConstraint->indicator == (uint8_t)DRM_NO_RIGHTS) {
    485         if (JNI_DRM_FAILURE == setObjectIntField(env, constraint, "count", 0))
    486             return JNI_DRM_FAILURE;
    487 
    488         return JNI_DRM_SUCCESS;
    489     }
    490 
    491     /* set count field */
    492     if (pConstraint->indicator & DRM_COUNT_CONSTRAINT) {
    493         if (JNI_DRM_FAILURE == setObjectIntField(env, constraint, "count", pConstraint->count))
    494             return JNI_DRM_FAILURE;
    495     }
    496 
    497     /* set start time field */
    498     if (pConstraint->indicator & DRM_START_TIME_CONSTRAINT) {
    499         int64_t startTime;
    500 
    501         startTime = computeTime(pConstraint->startDate, pConstraint->startTime);
    502 
    503         if (JNI_DRM_FAILURE == setObjectLongField(env, constraint, "startDate", startTime))
    504             return JNI_DRM_FAILURE;
    505     }
    506 
    507     /* set end time field */
    508     if (pConstraint->indicator & DRM_END_TIME_CONSTRAINT) {
    509         int64_t endTime;
    510 
    511         endTime = computeTime(pConstraint->endDate, pConstraint->endTime);
    512 
    513         if (JNI_DRM_FAILURE == setObjectLongField(env, constraint, "endDate", endTime))
    514             return JNI_DRM_FAILURE;
    515     }
    516 
    517     /* set interval field */
    518     if (pConstraint->indicator & DRM_INTERVAL_CONSTRAINT) {
    519         int64_t interval;
    520 
    521         interval = computeInterval(pConstraint->intervalDate, pConstraint->intervalTime);
    522 
    523         if (JNI_DRM_FAILURE == setObjectLongField(env, constraint, "interval", interval))
    524             return JNI_DRM_FAILURE;
    525     }
    526 
    527     return JNI_DRM_SUCCESS;
    528 }
    529 
    530 static jint setRightsFields(JNIEnv * env, jobject rights, T_DRM_Rights_Info* pRoInfo)
    531 {
    532     jclass clazz;
    533     jfieldID field;
    534     jstring str;
    535     jint index;
    536 
    537     clazz = (*env)->GetObjectClass(env, rights);
    538     if (NULL == clazz)
    539         return JNI_DRM_FAILURE;
    540 
    541     /* set roId field */
    542     field = (*env)->GetFieldID(env, clazz, "roId", "Ljava/lang/String;");
    543     (*env)->DeleteLocalRef(env, clazz);
    544 
    545     if (NULL == field)
    546         return JNI_DRM_FAILURE;
    547 
    548     str = (*env)->NewStringUTF(env, (char *)pRoInfo->roId);
    549     if (NULL == str)
    550         return JNI_DRM_FAILURE;
    551 
    552     (*env)->SetObjectField(env, rights, field, str);
    553     (*env)->DeleteLocalRef(env, str);
    554 
    555     return JNI_DRM_SUCCESS;
    556 }
    557 
    558 /* native interface */
    559 JNIEXPORT jint JNICALL
    560 Java_android_drm_mobile1_DrmRawContent_nativeConstructDrmContent
    561   (JNIEnv * env, jobject rawContent, jobject data, jint len, jint mimeType)
    562 {
    563     int32_t id;
    564     T_DRM_Input_Data inData;
    565     DrmData* drmInData;
    566 
    567     switch (mimeType) {
    568     case JNI_DRM_MIMETYPE_MESSAGE:
    569         mimeType = TYPE_DRM_MESSAGE;
    570         break;
    571     case JNI_DRM_MIMETYPE_CONTENT:
    572         mimeType = TYPE_DRM_CONTENT;
    573         break;
    574     default:
    575         return JNI_DRM_FAILURE;
    576     }
    577 
    578     drmInData = newItem();
    579     if (NULL == drmInData)
    580         return JNI_DRM_FAILURE;
    581 
    582     drmInData->env = env;
    583     drmInData->pInData = &data;
    584     drmInData->len = len;
    585 
    586     if (JNI_DRM_FAILURE == addItem(drmInData))
    587         return JNI_DRM_FAILURE;
    588 
    589     inData.inputHandle = (int32_t)drmInData;
    590     inData.mimeType = mimeType;
    591     inData.getInputDataLength = getInputStreamDataLength;
    592     inData.readInputData = readInputStreamData;
    593 
    594     id = SVC_drm_openSession(inData);
    595     if (id < 0)
    596         return JNI_DRM_FAILURE;
    597 
    598     drmInData->id = id;
    599 
    600     return id;
    601 }
    602 
    603 /* native interface */
    604 JNIEXPORT jstring JNICALL
    605 Java_android_drm_mobile1_DrmRawContent_nativeGetRightsAddress
    606   (JNIEnv * env, jobject rawContent)
    607 {
    608     jint id;
    609     uint8_t rightsIssuer[256] = {0};
    610     jstring str = NULL;
    611 
    612     if (JNI_DRM_FAILURE == getObjectIntField(env, rawContent, "id", &id))
    613         return NULL;
    614 
    615     if (DRM_SUCCESS == SVC_drm_getRightsIssuer(id, rightsIssuer))
    616         str = (*env)->NewStringUTF(env, (char *)rightsIssuer);
    617 
    618     return str;
    619 }
    620 
    621 /* native interface */
    622 JNIEXPORT jint JNICALL
    623 Java_android_drm_mobile1_DrmRawContent_nativeGetDeliveryMethod
    624   (JNIEnv * env, jobject rawContent)
    625 {
    626     jint id;
    627     int32_t res;
    628 
    629     if (JNI_DRM_FAILURE == getObjectIntField(env, rawContent, "id", &id))
    630         return JNI_DRM_FAILURE;
    631 
    632     res = SVC_drm_getDeliveryMethod(id);
    633 
    634     switch (res) {
    635     case FORWARD_LOCK:
    636         return JNI_DRM_FORWARD_LOCK;
    637     case COMBINED_DELIVERY:
    638         return JNI_DRM_COMBINED_DELIVERY;
    639     case SEPARATE_DELIVERY:
    640         return JNI_DRM_SEPARATE_DELIVERY;
    641     case SEPARATE_DELIVERY_FL:
    642         return JNI_DRM_SEPARATE_DELIVERY_DM;
    643     default:
    644         return JNI_DRM_FAILURE;
    645     }
    646 }
    647 
    648 /* native interface */
    649 JNIEXPORT jint JNICALL
    650 Java_android_drm_mobile1_DrmRawContent_nativeReadContent
    651   (JNIEnv * env, jobject rawContent, jbyteArray buf, jint bufOff, jint len, jint mediaOff)
    652 {
    653     jint id;
    654     jbyte *nativeBuf;
    655     jclass cls;
    656     jmethodID mid;
    657     DrmData* p;
    658     jobject inputStream;
    659     jfieldID field;
    660 
    661     if (NULL == buf) {
    662         jclass newExcCls = (*env)->FindClass(env, "java/lang/NullPointerException");
    663 
    664         if (newExcCls == NULL)
    665             /* Unable to find the exception class, give up. */
    666             return JNI_DRM_FAILURE;
    667 
    668         (*env)->ThrowNew(env, newExcCls, "b is null");
    669     }
    670 
    671     if (len < 0 || bufOff < 0 || len + bufOff > (*env)->GetArrayLength(env, buf)) {
    672         jclass newExcCls = (*env)->FindClass(env, "java/lang/IndexOutOfBoundsException");
    673 
    674         if (newExcCls == NULL)
    675             /* Unable to find the exception class, give up. */
    676             return JNI_DRM_FAILURE;
    677 
    678         (*env)->ThrowNew(env, newExcCls, NULL);
    679     }
    680 
    681     if (mediaOff < 0 || len == 0)
    682         return JNI_DRM_FAILURE;
    683 
    684     if (JNI_DRM_FAILURE == getObjectIntField(env, rawContent, "id", &id))
    685         return JNI_DRM_FAILURE;
    686 
    687     p = getItem(id);
    688     if (NULL == p)
    689         return JNI_DRM_FAILURE;
    690 
    691     cls = (*env)->GetObjectClass(env, rawContent);
    692     if (NULL == cls)
    693         return JNI_DRM_FAILURE;
    694 
    695     field = (*env)->GetFieldID(env, cls, "inData", "Ljava/io/BufferedInputStream;");
    696     (*env)->DeleteLocalRef(env, cls);
    697 
    698     if (NULL == field)
    699         return JNI_DRM_FAILURE;
    700 
    701     inputStream = (*env)->GetObjectField(env, rawContent, field);
    702 
    703     p->env = env;
    704     p->pInData = &inputStream;
    705 
    706     nativeBuf = (*env)->GetByteArrayElements(env, buf, NULL);
    707 
    708     len = SVC_drm_getContent(id, mediaOff, (uint8_t *)nativeBuf + bufOff, len);
    709 
    710     (*env)->ReleaseByteArrayElements(env, buf, nativeBuf, 0);
    711 
    712     if (DRM_MEDIA_EOF == len)
    713         return JNI_DRM_EOF;
    714     if (len <= 0)
    715         return JNI_DRM_FAILURE;
    716 
    717     return len;
    718 }
    719 
    720 /* native interface */
    721 JNIEXPORT jstring JNICALL
    722 Java_android_drm_mobile1_DrmRawContent_nativeGetContentType
    723   (JNIEnv * env, jobject rawContent)
    724 {
    725     jint id;
    726     uint8_t contentType[64] = {0};
    727     jstring str = NULL;
    728 
    729     if (JNI_DRM_FAILURE == getObjectIntField(env, rawContent, "id", &id))
    730         return NULL;
    731 
    732     if (DRM_SUCCESS == SVC_drm_getContentType(id, contentType))
    733         str = (*env)->NewStringUTF(env, (char *)contentType);
    734 
    735     return str;
    736 }
    737 
    738 /* native interface */
    739 JNIEXPORT jint JNICALL
    740 Java_android_drm_mobile1_DrmRawContent_nativeGetContentLength
    741   (JNIEnv * env, jobject rawContent)
    742 {
    743     jint id;
    744     int32_t len;
    745 
    746     if (JNI_DRM_FAILURE == getObjectIntField(env, rawContent, "id", &id))
    747         return JNI_DRM_FAILURE;
    748 
    749     len = SVC_drm_getContentLength(id);
    750 
    751     if (DRM_UNKNOWN_DATA_LEN == len)
    752         return JNI_DRM_UNKNOWN_DATA_LEN;
    753 
    754     if (0 > len)
    755         return JNI_DRM_FAILURE;
    756 
    757     return len;
    758 }
    759 
    760 /* native interface */
    761 JNIEXPORT void JNICALL
    762 Java_android_drm_mobile1_DrmRawContent_finalize
    763   (JNIEnv * env, jobject rawContent)
    764 {
    765     jint id;
    766 
    767     if (JNI_DRM_FAILURE == getObjectIntField(env, rawContent, "id", &id))
    768         return;
    769 
    770     removeItem(id);
    771 
    772     SVC_drm_closeSession(id);
    773 }
    774 
    775 /* native interface */
    776 JNIEXPORT jint JNICALL
    777 Java_android_drm_mobile1_DrmRights_nativeGetConstraintInfo
    778   (JNIEnv * env, jobject rights, jint permission, jobject constraint)
    779 {
    780     jclass clazz;
    781     jfieldID field;
    782     jstring str;
    783     uint8_t *nativeStr;
    784     T_DRM_Rights_Info_Node *pRightsList;
    785     T_DRM_Rights_Info_Node *pCurNode;
    786     T_DRM_Constraint_Info *pConstraint;
    787 
    788     clazz = (*env)->GetObjectClass(env, rights);
    789     if (NULL == clazz)
    790         return JNI_DRM_FAILURE;
    791 
    792     field = (*env)->GetFieldID(env, clazz, "roId", "Ljava/lang/String;");
    793     (*env)->DeleteLocalRef(env, clazz);
    794 
    795     if (NULL == field)
    796         return JNI_DRM_FAILURE;
    797 
    798     str = (*env)->GetObjectField(env, rights, field);
    799 
    800     nativeStr = (uint8_t *)(*env)->GetStringUTFChars(env, str, NULL);
    801     if (NULL == nativeStr)
    802         return JNI_DRM_FAILURE;
    803 
    804     /* this means forward-lock rights */
    805     if (0 == strcmp((char *)nativeStr, "ForwardLock")) {
    806         (*env)->ReleaseStringUTFChars(env, str, (char *)nativeStr);
    807         return JNI_DRM_SUCCESS;
    808     }
    809 
    810     if (DRM_FAILURE == SVC_drm_viewAllRights(&pRightsList)) {
    811         (*env)->ReleaseStringUTFChars(env, str, (char *)nativeStr);
    812         return JNI_DRM_FAILURE;
    813     }
    814 
    815     pCurNode = searchRightsObject((jbyte *)nativeStr, pRightsList);
    816     if (NULL == pCurNode) {
    817         (*env)->ReleaseStringUTFChars(env, str, (char *)nativeStr);
    818         SVC_drm_freeRightsInfoList(pRightsList);
    819         return JNI_DRM_FAILURE;
    820     }
    821     (*env)->ReleaseStringUTFChars(env, str, (char *)nativeStr);
    822 
    823     switch (permission) {
    824     case JNI_DRM_PERMISSION_PLAY:
    825         pConstraint = &(pCurNode->roInfo.playRights);
    826         break;
    827     case JNI_DRM_PERMISSION_DISPLAY:
    828         pConstraint = &(pCurNode->roInfo.displayRights);
    829         break;
    830     case JNI_DRM_PERMISSION_EXECUTE:
    831         pConstraint = &(pCurNode->roInfo.executeRights);
    832         break;
    833     case JNI_DRM_PERMISSION_PRINT:
    834         pConstraint = &(pCurNode->roInfo.printRights);
    835         break;
    836     default:
    837         SVC_drm_freeRightsInfoList(pRightsList);
    838         return JNI_DRM_FAILURE;
    839     }
    840 
    841     /* set constraint field */
    842     if (JNI_DRM_FAILURE == setConstraintFields(env, constraint, pConstraint)) {
    843         SVC_drm_freeRightsInfoList(pRightsList);
    844         return JNI_DRM_FAILURE;
    845     }
    846 
    847     SVC_drm_freeRightsInfoList(pRightsList);
    848 
    849     return JNI_DRM_SUCCESS;
    850 }
    851 
    852 /* native interface */
    853 JNIEXPORT jint JNICALL
    854 Java_android_drm_mobile1_DrmRights_nativeConsumeRights
    855   (JNIEnv * env, jobject rights, jint permission)
    856 {
    857     jclass clazz;
    858     jfieldID field;
    859     jstring str;
    860     uint8_t *nativeStr;
    861     int32_t id;
    862 
    863     switch (permission) {
    864     case JNI_DRM_PERMISSION_PLAY:
    865         permission = DRM_PERMISSION_PLAY;
    866         break;
    867     case JNI_DRM_PERMISSION_DISPLAY:
    868         permission = DRM_PERMISSION_DISPLAY;
    869         break;
    870     case JNI_DRM_PERMISSION_EXECUTE:
    871         permission = DRM_PERMISSION_EXECUTE;
    872         break;
    873     case JNI_DRM_PERMISSION_PRINT:
    874         permission = DRM_PERMISSION_PRINT;
    875         break;
    876     default:
    877         return JNI_DRM_FAILURE;
    878     }
    879 
    880     clazz = (*env)->GetObjectClass(env, rights);
    881     if (NULL == clazz)
    882         return JNI_DRM_FAILURE;
    883 
    884     field = (*env)->GetFieldID(env, clazz, "roId", "Ljava/lang/String;");
    885     (*env)->DeleteLocalRef(env, clazz);
    886 
    887     if (NULL == field)
    888         return JNI_DRM_FAILURE;
    889 
    890     str = (*env)->GetObjectField(env, rights, field);
    891 
    892     nativeStr = (uint8_t *)(*env)->GetStringUTFChars(env, str, NULL);
    893     if (NULL == nativeStr)
    894         return JNI_DRM_FAILURE;
    895 
    896     if (0 == strcmp("ForwardLock", (char *)nativeStr)) {
    897         (*env)->ReleaseStringUTFChars(env, str, (char *)nativeStr);
    898         return JNI_DRM_SUCCESS;
    899     }
    900 
    901     if (DRM_SUCCESS != SVC_drm_updateRights(nativeStr, permission)) {
    902         (*env)->ReleaseStringUTFChars(env, str, (char *)nativeStr);
    903         return JNI_DRM_FAILURE;
    904     }
    905 
    906     (*env)->ReleaseStringUTFChars(env, str, (char *)nativeStr);
    907 
    908     return JNI_DRM_SUCCESS;
    909 }
    910 
    911 /* native interface */
    912 JNIEXPORT jint JNICALL
    913 Java_android_drm_mobile1_DrmRightsManager_nativeInstallDrmRights
    914   (JNIEnv * env, jobject rightsManager, jobject data, jint len, jint mimeType, jobject rights)
    915 {
    916     int32_t id;
    917     T_DRM_Input_Data inData;
    918     DrmData* drmInData;
    919     jclass cls;
    920     jmethodID mid;
    921     T_DRM_Rights_Info rightsInfo;
    922 
    923     switch (mimeType) {
    924     case JNI_DRM_MIMETYPE_RIGHTS_XML:
    925         mimeType = TYPE_DRM_RIGHTS_XML;
    926         break;
    927     case JNI_DRM_MIMETYPE_RIGHTS_WBXML:
    928         mimeType = TYPE_DRM_RIGHTS_WBXML;
    929         break;
    930     case JNI_DRM_MIMETYPE_MESSAGE:
    931         mimeType = TYPE_DRM_MESSAGE;
    932         break;
    933     default:
    934         return JNI_DRM_FAILURE;
    935     }
    936 
    937     drmInData = newItem();
    938     if (NULL == drmInData)
    939         return JNI_DRM_FAILURE;
    940 
    941     drmInData->env = env;
    942     drmInData->pInData = &data;
    943     drmInData->len = len;
    944 
    945     inData.inputHandle = (int32_t)drmInData;
    946     inData.mimeType = mimeType;
    947     inData.getInputDataLength = getInputStreamDataLength;
    948     inData.readInputData = readInputStreamData;
    949 
    950     memset(&rightsInfo, 0, sizeof(T_DRM_Rights_Info));
    951     if (DRM_FAILURE == SVC_drm_installRights(inData, &rightsInfo))
    952         return JNI_DRM_FAILURE;
    953 
    954     freeItem(drmInData);
    955 
    956     return setRightsFields(env, rights, &rightsInfo);
    957 }
    958 
    959 /* native interface */
    960 JNIEXPORT jint JNICALL
    961 Java_android_drm_mobile1_DrmRightsManager_nativeQueryRights
    962   (JNIEnv * env, jobject rightsManager, jobject rawContent, jobject rights)
    963 {
    964     jint id;
    965     T_DRM_Rights_Info rightsInfo;
    966 
    967     if (JNI_DRM_FAILURE == getObjectIntField(env, rawContent, "id", &id))
    968         return JNI_DRM_FAILURE;
    969 
    970     memset(&rightsInfo, 0, sizeof(T_DRM_Rights_Info));
    971     if (DRM_SUCCESS != SVC_drm_getRightsInfo(id, &rightsInfo))
    972         return JNI_DRM_FAILURE;
    973 
    974     return setRightsFields(env, rights, &rightsInfo);
    975 }
    976 
    977 /* native interface */
    978 JNIEXPORT jint JNICALL
    979 Java_android_drm_mobile1_DrmRightsManager_nativeGetNumOfRights
    980   (JNIEnv * env, jobject rightsManager)
    981 {
    982     T_DRM_Rights_Info_Node *pRightsList;
    983     T_DRM_Rights_Info_Node *pCurNode;
    984     int32_t num = 0;
    985 
    986     if (DRM_FAILURE == SVC_drm_viewAllRights(&pRightsList))
    987         return JNI_DRM_FAILURE;
    988 
    989     pCurNode = pRightsList;
    990     while (pCurNode != NULL) {
    991         num++;
    992         pCurNode = pCurNode->next;
    993     }
    994 
    995     SVC_drm_freeRightsInfoList(pRightsList);
    996 
    997     return num;
    998 }
    999 
   1000 /* native interface */
   1001 JNIEXPORT jint JNICALL
   1002 Java_android_drm_mobile1_DrmRightsManager_nativeGetRightsList
   1003   (JNIEnv * env, jobject rightsManager, jobjectArray rightsArray, jint num)
   1004 {
   1005     T_DRM_Rights_Info_Node *pRightsList;
   1006     T_DRM_Rights_Info_Node *pCurNode;
   1007     int32_t index;
   1008 
   1009     if (DRM_FAILURE == SVC_drm_viewAllRights(&pRightsList))
   1010         return JNI_DRM_FAILURE;
   1011 
   1012     pCurNode = pRightsList;
   1013     for (index = 0; NULL != pCurNode; index++) {
   1014         jobject rights = (*env)->GetObjectArrayElement(env, rightsArray, index);
   1015         if (NULL == rights)
   1016             break;
   1017 
   1018         if (JNI_DRM_FAILURE == setRightsFields(env, rights, &(pCurNode->roInfo)))
   1019             break;
   1020 
   1021         (*env)->SetObjectArrayElement(env, rightsArray, index, rights);
   1022 
   1023         pCurNode = pCurNode->next;
   1024     }
   1025 
   1026     SVC_drm_freeRightsInfoList(pRightsList);
   1027 
   1028     return index;
   1029 }
   1030 
   1031 /* native interface */
   1032 JNIEXPORT jint JNICALL
   1033 Java_android_drm_mobile1_DrmRightsManager_nativeDeleteRights
   1034   (JNIEnv * env, jobject rightsManager, jobject rights)
   1035 {
   1036     jclass clazz;
   1037     jfieldID field;
   1038     jstring str;
   1039     uint8_t *nativeStr;
   1040 
   1041     clazz = (*env)->GetObjectClass(env, rights);
   1042     if (NULL == clazz)
   1043         return JNI_DRM_FAILURE;
   1044 
   1045     field = (*env)->GetFieldID(env, clazz, "roId", "Ljava/lang/String;");
   1046     if (NULL == field)
   1047         return JNI_DRM_FAILURE;
   1048 
   1049     str = (*env)->GetObjectField(env, rights, field);
   1050 
   1051     nativeStr = (uint8_t *)(*env)->GetStringUTFChars(env, str, NULL);
   1052     if (NULL == nativeStr)
   1053         return JNI_DRM_FAILURE;
   1054 
   1055     if (0 == strcmp("ForwardLock", (char *)nativeStr))
   1056         return JNI_DRM_SUCCESS;
   1057 
   1058     if (DRM_SUCCESS != SVC_drm_deleteRights(nativeStr)) {
   1059         (*env)->ReleaseStringUTFChars(env, str, (char *)nativeStr);
   1060         return JNI_DRM_FAILURE;
   1061     }
   1062 
   1063     (*env)->ReleaseStringUTFChars(env, str, (char *)nativeStr);
   1064     return JNI_DRM_SUCCESS;
   1065 }
   1066 
   1067 /*
   1068  * Table of methods associated with the DrmRawContent class.
   1069  */
   1070 static JNINativeMethod gDrmRawContentMethods[] = {
   1071     /* name, signature, funcPtr */
   1072     {"nativeConstructDrmContent", "(Ljava/io/InputStream;II)I",
   1073         (void*)Java_android_drm_mobile1_DrmRawContent_nativeConstructDrmContent},
   1074     {"nativeGetRightsAddress", "()Ljava/lang/String;",
   1075         (void*)Java_android_drm_mobile1_DrmRawContent_nativeGetRightsAddress},
   1076     {"nativeGetDeliveryMethod", "()I",
   1077         (void*)Java_android_drm_mobile1_DrmRawContent_nativeGetDeliveryMethod},
   1078     {"nativeReadContent", "([BIII)I",
   1079         (void*)Java_android_drm_mobile1_DrmRawContent_nativeReadContent},
   1080     {"nativeGetContentType", "()Ljava/lang/String;",
   1081         (void*)Java_android_drm_mobile1_DrmRawContent_nativeGetContentType},
   1082     {"nativeGetContentLength", "()I",
   1083         (void*)Java_android_drm_mobile1_DrmRawContent_nativeGetContentLength},
   1084     {"finalize", "()V",
   1085         (void*)Java_android_drm_mobile1_DrmRawContent_finalize},
   1086 };
   1087 
   1088 /*
   1089  * Table of methods associated with the DrmRights class.
   1090  */
   1091 static JNINativeMethod gDrmRightsMethods[] = {
   1092     /* name, signature, funcPtr */
   1093     {"nativeGetConstraintInfo", "(ILandroid/drm/mobile1/DrmConstraintInfo;)I",
   1094         (void*)Java_android_drm_mobile1_DrmRights_nativeGetConstraintInfo},
   1095     {"nativeConsumeRights", "(I)I",
   1096         (void*)Java_android_drm_mobile1_DrmRights_nativeConsumeRights},
   1097 };
   1098 
   1099 /*
   1100  * Table of methods associated with the DrmRightsManager class.
   1101  */
   1102 static JNINativeMethod gDrmRightsManagerMethods[] = {
   1103     /* name, signature, funcPtr */
   1104     {"nativeInstallDrmRights", "(Ljava/io/InputStream;IILandroid/drm/mobile1/DrmRights;)I",
   1105         (void*)Java_android_drm_mobile1_DrmRightsManager_nativeInstallDrmRights},
   1106     {"nativeQueryRights", "(Landroid/drm/mobile1/DrmRawContent;Landroid/drm/mobile1/DrmRights;)I",
   1107         (void*)Java_android_drm_mobile1_DrmRightsManager_nativeQueryRights},
   1108     {"nativeGetNumOfRights", "()I",
   1109         (void*)Java_android_drm_mobile1_DrmRightsManager_nativeGetNumOfRights},
   1110     {"nativeGetRightsList", "([Landroid/drm/mobile1/DrmRights;I)I",
   1111         (void*)Java_android_drm_mobile1_DrmRightsManager_nativeGetRightsList},
   1112     {"nativeDeleteRights", "(Landroid/drm/mobile1/DrmRights;)I",
   1113         (void*)Java_android_drm_mobile1_DrmRightsManager_nativeDeleteRights},
   1114 };
   1115 
   1116 /*
   1117  * Register several native methods for one class.
   1118  */
   1119 static int registerNativeMethods(JNIEnv* env, const char* className,
   1120     JNINativeMethod* gMethods, int numMethods)
   1121 {
   1122     jclass clazz;
   1123 
   1124     clazz = (*env)->FindClass(env, className);
   1125     if (clazz == NULL)
   1126         return JNI_FALSE;
   1127 
   1128     if ((*env)->RegisterNatives(env, clazz, gMethods, numMethods) < 0)
   1129         return JNI_FALSE;
   1130 
   1131     return JNI_TRUE;
   1132 }
   1133 
   1134 /*
   1135  * Register native methods for all classes we know about.
   1136  */
   1137 static int registerNatives(JNIEnv* env)
   1138 {
   1139     if (!registerNativeMethods(env, "android/drm/mobile1/DrmRawContent",
   1140             gDrmRawContentMethods, sizeof(gDrmRawContentMethods) / sizeof(gDrmRawContentMethods[0])))
   1141         return JNI_FALSE;
   1142 
   1143     if (!registerNativeMethods(env, "android/drm/mobile1/DrmRights",
   1144             gDrmRightsMethods, sizeof(gDrmRightsMethods) / sizeof(gDrmRightsMethods[0])))
   1145         return JNI_FALSE;
   1146 
   1147     if (!registerNativeMethods(env, "android/drm/mobile1/DrmRightsManager",
   1148             gDrmRightsManagerMethods, sizeof(gDrmRightsManagerMethods) / sizeof(gDrmRightsManagerMethods[0])))
   1149         return JNI_FALSE;
   1150 
   1151     return JNI_TRUE;
   1152 }
   1153 
   1154 jint JNI_OnLoad(JavaVM* vm, void* reserved)
   1155 {
   1156     JNIEnv* env = NULL;
   1157     jint result = -1;
   1158 
   1159     printf("Entering JNI_OnLoad\n");
   1160 
   1161     if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_4) != JNI_OK)
   1162         goto bail;
   1163 
   1164     assert(env != NULL);
   1165 
   1166     if (!registerNatives(env))
   1167         goto bail;
   1168 
   1169     /* success -- return valid version number */
   1170     result = JNI_VERSION_1_4;
   1171 
   1172 bail:
   1173     printf("Leaving JNI_OnLoad (result=0x%x)\n", result);
   1174     return result;
   1175 }
   1176