/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <svc_drm.h>
#include <drm_inner.h>
#include <parser_dm.h>
#include <parser_dcf.h>
#include <parser_rel.h>
#include <drm_rights_manager.h>
#include <drm_time.h>
#include <drm_decoder.h>
#include "log.h"
/**
* Current id.
*/
static int32_t curID = 0;
/**
* The header pointer for the session list.
*/
static T_DRM_Session_Node* sessionTable = NULL;
/**
* New a session.
*/
static T_DRM_Session_Node* newSession(T_DRM_Input_Data data)
{
T_DRM_Session_Node* s = (T_DRM_Session_Node *)malloc(sizeof(T_DRM_Session_Node));
if (NULL != s) {
memset(s, 0, sizeof(T_DRM_Session_Node));
s->sessionId = curID++;
s->inputHandle = data.inputHandle;
s->mimeType = data.mimeType;
s->getInputDataLengthFunc = data.getInputDataLength;
s->readInputDataFunc = data.readInputData;
s->seekInputDataFunc = data.seekInputData;
}
return s;
}
/**
* Free a session.
*/
static void freeSession(T_DRM_Session_Node* s)
{
if (NULL == s)
return;
if (NULL != s->rawContent)
free(s->rawContent);
if (NULL != s->readBuf)
free(s->readBuf);
if (NULL != s->infoStruct)
free(s->infoStruct);
free(s);
}
/**
* Add a session to list.
*/
static int32_t addSession(T_DRM_Session_Node* s)
{
if (NULL == s)
return -1;
s->next = sessionTable;
sessionTable = s;
return s->sessionId;
}
/**
* Get a session from the list.
*/
static T_DRM_Session_Node* getSession(int32_t sessionId)
{
T_DRM_Session_Node* s;
if (sessionId < 0 || NULL == sessionTable)
return NULL;
for (s = sessionTable; s != NULL; s = s->next) {
if (sessionId == s->sessionId)
return s;
}
return NULL;
}
/**
* Remove a session from the list.
*/
static void removeSession(int32_t sessionId)
{
T_DRM_Session_Node *curS, *preS;
if (sessionId < 0 || NULL == sessionTable)
return;
if (sessionId == sessionTable->sessionId) {
curS = sessionTable;
sessionTable = curS->next;
freeSession(curS);
return;
}
for (preS = sessionTable; preS->next != NULL; preS = preS->next) {
if (preS->next->sessionId == sessionId)
curS = preS->next;
}
if (NULL == preS->next)
return;
preS->next = curS->next;
freeSession(curS);
}
/**
* Try to identify the mimetype according the input DRM data.
*/
static int32_t getMimeType(const uint8_t *buf, int32_t bufLen)
{
const uint8_t *p;
if (NULL == buf || bufLen <= 0)
return TYPE_DRM_UNKNOWN;
p = buf;
/* check if it is DRM Content Format, only check the first field of Version, it must be "0x01" */
if (0x01 == *p)
return TYPE_DRM_CONTENT;
/* check if it is DRM Message, only check the first two bytes, it must be the start flag of boundary: "--" */
if (bufLen >= 2 && '-' == *p && '-' == *(p + 1))
return TYPE_DRM_MESSAGE;
/* check if it is DRM Rights XML format, only check the first several bytes, it must be: "<o-ex:rights" */
if (bufLen >= 12 && 0 == strncmp("<o-ex:rights", (char *)p, 12))
return TYPE_DRM_RIGHTS_XML;
/* check if it is DRM Rights WBXML format, only check the first two bytes, it must be: 0x03, 0x0e */
if (bufLen >= 2 && 0x03 == *p && 0x0e == *(p + 1))
return TYPE_DRM_RIGHTS_WBXML;
return TYPE_DRM_UNKNOWN;
}
static int32_t drm_skipCRLFinB64(const uint8_t* b64Data, int32_t len)
{
const uint8_t* p;
int32_t skipLen = 0;
if (NULL == b64Data || len <= 0)
return -1;
p = b64Data;
while (p - b64Data < len) {
if ('\r' == *p || '\n'== *p)
skipLen++;
p++;
}
return skipLen;
}
static int32_t drm_scanEndBoundary(const uint8_t* pBuf, int32_t len, uint8_t* const boundary)
{
const uint8_t* p;
int32_t leftLen;
int32_t boundaryLen;
if (NULL == pBuf || len <=0 || NULL == boundary)
return -1;
p = pBuf;
boundaryLen = strlen((char *)boundary) + 2; /* 2 means: '\r' and '\n' */
leftLen = len - (p - pBuf);
while (leftLen > 0) {
if (NULL == (p = memchr(p, '\r', leftLen)))
break;
leftLen = len - (p - pBuf);
if (leftLen < boundaryLen)
return -2; /* here means may be the boundary has been split */
if (('\n' == *(p + 1)) && (0 == memcmp(p + 2, boundary, strlen((char *)boundary))))
return p - pBuf; /* find the boundary here */
p++;
leftLen--;
}
return len; /* no boundary found */
}
static int32_t drm_getLicenseInfo(T_DRM_Rights* pRights, T_DRM_Rights_Info* licenseInfo)
{
if (NULL != licenseInfo && NULL != pRights) {
strcpy((char *)licenseInfo->roId, (char *)pRights->uid);
if (1 == pRights->bIsDisplayable) {
licenseInfo->displayRights.indicator = pRights->DisplayConstraint.Indicator;
licenseInfo->displayRights.count =
pRights->DisplayConstraint.Count;
licenseInfo->displayRights.startDate =
pRights->DisplayConstraint.StartTime.date;
licenseInfo->displayRights.startTime =
pRights->DisplayConstraint.StartTime.time;
licenseInfo->displayRights.endDate =
pRights->DisplayConstraint.EndTime.date;
licenseInfo->displayRights.endTime =
pRights->DisplayConstraint.EndTime.time;
licenseInfo->displayRights.intervalDate =
pRights->DisplayConstraint.Interval.date;
licenseInfo->displayRights.intervalTime =
pRights->DisplayConstraint.Interval.time;
}
if (1 == pRights->bIsPlayable) {
licenseInfo->playRights.indicator = pRights->PlayConstraint.Indicator;
licenseInfo->playRights.count = pRights->PlayConstraint.Count;
licenseInfo->playRights.startDate =
pRights->PlayConstraint.StartTime.date;
licenseInfo->playRights.startTime =
pRights->PlayConstraint.StartTime.time;
licenseInfo->playRights.endDate =
pRights->PlayConstraint.EndTime.date;
licenseInfo->playRights.endTime =
pRights->PlayConstraint.EndTime.time;
licenseInfo->playRights.intervalDate =
pRights->PlayConstraint.Interval.date;
licenseInfo->playRights.intervalTime =
pRights->PlayConstraint.Interval.time;
}
if (1 == pRights->bIsExecuteable) {
licenseInfo->executeRights.indicator = pRights->ExecuteConstraint.Indicator;
licenseInfo->executeRights.count =
pRights->ExecuteConstraint.Count;
licenseInfo->executeRights.startDate =
pRights->ExecuteConstraint.StartTime.date;
licenseInfo->executeRights.startTime =
pRights->ExecuteConstraint.StartTime.time;
licenseInfo->executeRights.endDate =
pRights->ExecuteConstraint.EndTime.date;
licenseInfo->executeRights.endTime =
pRights->ExecuteConstraint.EndTime.time;
licenseInfo->executeRights.intervalDate =
pRights->ExecuteConstraint.Interval.date;
licenseInfo->executeRights.intervalTime =
pRights->ExecuteConstraint.Interval.time;
}
if (1 == pRights->bIsPrintable) {
licenseInfo->printRights.indicator = pRights->PrintConstraint.Indicator;
licenseInfo->printRights.count =
pRights->PrintConstraint.Count;
licenseInfo->printRights.startDate =
pRights->PrintConstraint.StartTime.date;
licenseInfo->printRights.startTime =
pRights->PrintConstraint.StartTime.time;
licenseInfo->printRights.endDate =
pRights->PrintConstraint.EndTime.date;
licenseInfo->printRights.endTime =
pRights->PrintConstraint.EndTime.time;
licenseInfo->printRights.intervalDate =
pRights->PrintConstraint.Interval.date;
licenseInfo->printRights.intervalTime =
pRights->PrintConstraint.Interval.time;
}
return TRUE;
}
return FALSE;
}
static int32_t drm_addRightsNodeToList(T_DRM_Rights_Info_Node **ppRightsHeader,
T_DRM_Rights_Info_Node *pInputRightsNode)
{
T_DRM_Rights_Info_Node *pRightsNode;
if (NULL == ppRightsHeader || NULL == pInputRightsNode)
return FALSE;
pRightsNode = (T_DRM_Rights_Info_Node *)malloc(sizeof(T_DRM_Rights_Info_Node));
if (NULL == pRightsNode)
return FALSE;
memcpy(pRightsNode, pInputRightsNode, sizeof(T_DRM_Rights_Info_Node));
pRightsNode->next = NULL;
/* this means it is the first node */
if (NULL == *ppRightsHeader)
*ppRightsHeader = pRightsNode;
else {
T_DRM_Rights_Info_Node *pTmp;
pTmp = *ppRightsHeader;
while (NULL != pTmp->next)
pTmp = pTmp->next;
pTmp->next = pRightsNode;
}
return TRUE;
}
static int32_t drm_startConsumeRights(int32_t * bIsXXable,
T_DRM_Rights_Constraint * XXConstraint,
int32_t * writeFlag)
{
T_DB_TIME_SysTime curDateTime;
T_DRM_DATETIME CurrentTime;
uint8_t countFlag = 0;
memset(&CurrentTime, 0, sizeof(T_DRM_DATETIME));
if (NULL == bIsXXable || 0 == *bIsXXable || NULL == XXConstraint || NULL == writeFlag)
return DRM_FAILURE;
if (0 != (uint8_t)(XXConstraint->Indicator & DRM_NO_CONSTRAINT)) /* Have utter right? */
return DRM_SUCCESS;
*bIsXXable = 0; /* Assume have invalid rights at first */
*writeFlag = 0;
if (0 != (XXConstraint->Indicator & (DRM_START_TIME_CONSTRAINT | DRM_END_TIME_CONSTRAINT | DRM_INTERVAL_CONSTRAINT))) {
DRM_time_getSysTime(&curDateTime);
if (-1 == drm_checkDate(curDateTime.year, curDateTime.month, curDateTime.day,
curDateTime.hour, curDateTime.min, curDateTime.sec))
return DRM_FAILURE;
YMD_HMS_2_INT(curDateTime.year, curDateTime.month, curDateTime.day,
CurrentTime.date, curDateTime.hour, curDateTime.min,
curDateTime.sec, CurrentTime.time);
}
if (0 != (uint8_t)(XXConstraint->Indicator & DRM_COUNT_CONSTRAINT)) { /* Have count restrict? */
*writeFlag = 1;
/* If it has only one time for use, after use this function, we will delete this rights */
if (XXConstraint->Count <= 0) {
XXConstraint->Indicator &= ~DRM_COUNT_CONSTRAINT;
return DRM_RIGHTS_EXPIRED;
}
if (XXConstraint->Count-- <= 1) {
XXConstraint->Indicator &= ~DRM_COUNT_CONSTRAINT;
countFlag = 1;
}
}
if (0 != (uint8_t)(XXConstraint->Indicator & DRM_START_TIME_CONSTRAINT)) {
if (XXConstraint->StartTime.date > CurrentTime.date ||
(XXConstraint->StartTime.date == CurrentTime.date &&
XXConstraint->StartTime.time >= CurrentTime.time)) {
*bIsXXable = 1;
return DRM_RIGHTS_PENDING;
}
}
if (0 != (uint8_t)(XXConstraint->Indicator & DRM_END_TIME_CONSTRAINT)) { /* Have end time restrict? */
if (XXConstraint->EndTime.date < CurrentTime.date ||
(XXConstraint->EndTime.date == CurrentTime.date &&
XXConstraint->EndTime.time <= CurrentTime.time)) {
*writeFlag = 1;
XXConstraint->Indicator &= ~DRM_END_TIME_CONSTRAINT;
return DRM_RIGHTS_EXPIRED;
}
}
if (0 != (uint8_t)(XXConstraint->Indicator & DRM_INTERVAL_CONSTRAINT)) { /* Have interval time restrict? */
int32_t year, mon, day, hour, min, sec, date, time;
int32_t ret;
XXConstraint->Indicator |= DRM_END_TIME_CONSTRAINT;
XXConstraint->Indicator &= ~DRM_INTERVAL_CONSTRAINT; /* Write off interval right */
*writeFlag = 1;
if (XXConstraint->Interval.date == 0
&& XXConstraint->Interval.time == 0) {
return DRM_RIGHTS_EXPIRED;
}
date = CurrentTime.date + XXConstraint->Interval.date;
time = CurrentTime.time + XXConstraint->Interval.time;
INT_2_YMD_HMS(year, mon, day, date, hour, min, sec, time);
if (sec > 59) {
min += sec / 60;
sec %= 60;
}
if (min > 59) {
hour += min / 60;
min %= 60;
}
if (hour > 23) {
day += hour / 24;
hour %= 24;
}
if (day > 31) {
mon += day / 31;
day %= 31;
}
if (mon > 12) {
year += mon / 12;
mon %= 12;
}
if (day > (ret = drm_monthDays(year, mon))) {
day -= ret;
mon++;
if (mon > 12) {
mon -= 12;
year++;
}
}
YMD_HMS_2_INT(year, mon, day, XXConstraint->EndTime.date, hour,
min, sec, XXConstraint->EndTime.time);
}
if (1 != countFlag)
*bIsXXable = 1; /* Can go here ,so right must be valid */
return DRM_SUCCESS;
}
static int32_t drm_startCheckRights(int32_t * bIsXXable,
T_DRM_Rights_Constraint * XXConstraint)
{
T_DB_TIME_SysTime curDateTime;
T_DRM_DATETIME CurrentTime;
memset(&CurrentTime, 0, sizeof(T_DRM_DATETIME));
if (NULL == bIsXXable || 0 == *bIsXXable || NULL == XXConstraint)
return DRM_FAILURE;
if (0 != (uint8_t)(XXConstraint->Indicator & DRM_NO_CONSTRAINT)) /* Have utter right? */
return DRM_SUCCESS;
*bIsXXable = 0; /* Assume have invalid rights at first */
if (0 != (XXConstraint->Indicator & (DRM_START_TIME_CONSTRAINT | DRM_END_TIME_CONSTRAINT))) {
DRM_time_getSysTime(&curDateTime);
if (-1 == drm_checkDate(curDateTime.year, curDateTime.month, curDateTime.day,
curDateTime.hour, curDateTime.min, curDateTime.sec))
return DRM_FAILURE;
YMD_HMS_2_INT(curDateTime.year, curDateTime.month, curDateTime.day,
CurrentTime.date, curDateTime.hour, curDateTime.min,
curDateTime.sec, CurrentTime.time);
}
if (0 != (uint8_t)(XXConstraint->Indicator & DRM_COUNT_CONSTRAINT)) { /* Have count restrict? */
if (XXConstraint->Count <= 0) {
XXConstraint->Indicator &= ~DRM_COUNT_CONSTRAINT;
return DRM_RIGHTS_EXPIRED;
}
}
if (0 != (uint8_t)(XXConstraint->Indicator & DRM_START_TIME_CONSTRAINT)) {
if (XXConstraint->StartTime.date > CurrentTime.date ||
(XXConstraint->StartTime.date == CurrentTime.date &&
XXConstraint->StartTime.time >= CurrentTime.time)) {
*bIsXXable = 1;
return DRM_RIGHTS_PENDING;
}
}
if (0 != (uint8_t)(XXConstraint->Indicator & DRM_END_TIME_CONSTRAINT)) { /* Have end time restrict? */
if (XXConstraint->EndTime.date < CurrentTime.date ||
(XXConstraint->EndTime.date == CurrentTime.date &&
XXConstraint->EndTime.time <= CurrentTime.time)) {
XXConstraint->Indicator &= ~DRM_END_TIME_CONSTRAINT;
return DRM_RIGHTS_EXPIRED;
}
}
if (0 != (uint8_t)(XXConstraint->Indicator & DRM_INTERVAL_CONSTRAINT)) { /* Have interval time restrict? */
if (XXConstraint->Interval.date == 0 && XXConstraint->Interval.time == 0) {
XXConstraint->Indicator &= ~DRM_INTERVAL_CONSTRAINT;
return DRM_RIGHTS_EXPIRED;
}
}
*bIsXXable = 1;
return DRM_SUCCESS;
}
int32_t drm_checkRoAndUpdate(int32_t id, int32_t permission)
{
int32_t writeFlag = 0;
int32_t roAmount;
int32_t validRoAmount = 0;
int32_t flag = DRM_FAILURE;
int32_t i, j;
T_DRM_Rights *pRo;
T_DRM_Rights *pCurRo;
int32_t * pNumOfPriority;
int32_t iNum;
T_DRM_Rights_Constraint * pCurConstraint;
T_DRM_Rights_Constraint * pCompareConstraint;
int priority[8] = {1, 2, 4, 3, 8, 6, 7, 5};
if (FALSE == drm_writeOrReadInfo(id, NULL, &roAmount, GET_ROAMOUNT))
return DRM_FAILURE;
validRoAmount = roAmount;
if (roAmount < 1)
return DRM_NO_RIGHTS;
pRo = malloc(roAmount * sizeof(T_DRM_Rights));
pCurRo = pRo;
if (NULL == pRo)
return DRM_FAILURE;
if (FALSE == drm_writeOrReadInfo(id, pRo, &roAmount, GET_ALL_RO)) {
free(pRo);
return DRM_FAILURE;
}
/** check the right priority */
pNumOfPriority = malloc(sizeof(int32_t) * roAmount);
for(i = 0; i < roAmount; i++) {
iNum = roAmount - 1;
for(j = 0; j < roAmount; j++) {
if(i == j)
continue;
switch(permission) {
case DRM_PERMISSION_PLAY:
pCurConstraint = &pRo[i].PlayConstraint;
pCompareConstraint = &pRo[j].PlayConstraint;
break;
case DRM_PERMISSION_DISPLAY:
pCurConstraint = &pRo[i].DisplayConstraint;
pCompareConstraint = &pRo[j].DisplayConstraint;
break;
case DRM_PERMISSION_EXECUTE:
pCurConstraint = &pRo[i].ExecuteConstraint;
pCompareConstraint = &pRo[j].ExecuteConstraint;
break;
case DRM_PERMISSION_PRINT:
pCurConstraint = &pRo[i].PrintConstraint;
pCompareConstraint = &pRo[j].PrintConstraint;
break;
default:
free(pRo);
free(pNumOfPriority);
return DRM_FAILURE;
}
/**get priority by Indicator*/
if(0 == (pCurConstraint->Indicator & DRM_NO_CONSTRAINT) &&
0 == (pCompareConstraint->Indicator & DRM_NO_CONSTRAINT)) {
int num1, num2;
num1 = (pCurConstraint->Indicator & 0x0e) >> 1;
num2 = (pCompareConstraint->Indicator & 0x0e) >> 1;
if(priority[num1] > priority[num2]) {
iNum--;
continue;
} else if(priority[pCurConstraint->Indicator] < priority[pCompareConstraint->Indicator])
continue;
} else if(pCurConstraint->Indicator > pCompareConstraint->Indicator) {
iNum--;
continue;
} else if(pCurConstraint->Indicator < pCompareConstraint->Indicator)
continue;
if(0 != (pCurConstraint->Indicator & DRM_END_TIME_CONSTRAINT)) {
if(pCurConstraint->EndTime.date < pCompareConstraint->EndTime.date) {
iNum--;
continue;
} else if(pCurConstraint->EndTime.date > pCompareConstraint->EndTime.date)
continue;
if(pCurConstraint->EndTime.time < pCompareConstraint->EndTime.time) {
iNum--;
continue;
} else if(pCurConstraint->EndTime.date > pCompareConstraint->EndTime.date)
continue;
}
if(0 != (pCurConstraint->Indicator & DRM_INTERVAL_CONSTRAINT)) {
if(pCurConstraint->Interval.date < pCompareConstraint->Interval.date) {
iNum--;
continue;
} else if(pCurConstraint->Interval.date > pCompareConstraint->Interval.date)
continue;
if(pCurConstraint->Interval.time < pCompareConstraint->Interval.time) {
iNum--;
continue;
} else if(pCurConstraint->Interval.time > pCompareConstraint->Interval.time)
continue;
}
if(0 != (pCurConstraint->Indicator & DRM_COUNT_CONSTRAINT)) {
if(pCurConstraint->Count < pCompareConstraint->Count) {
iNum--;
continue;
} else if(pCurConstraint->Count > pCompareConstraint->Count)
continue;
}
if(i < j)
iNum--;
}
pNumOfPriority[iNum] = i;
}
for (i = 0; i < validRoAmount; i++) {
/** check the right priority */
if (pNumOfPriority[i] >= validRoAmount)
break;
pCurRo = pRo + pNumOfPriority[i];
switch (permission) {
case DRM_PERMISSION_PLAY:
flag =
drm_startConsumeRights(&pCurRo->bIsPlayable,
&pCurRo->PlayConstraint, &writeFlag);
break;
case DRM_PERMISSION_DISPLAY:
flag =
drm_startConsumeRights(&pCurRo->bIsDisplayable,
&pCurRo->DisplayConstraint,
&writeFlag);
break;
case DRM_PERMISSION_EXECUTE:
flag =
drm_startConsumeRights(&pCurRo->bIsExecuteable,
&pCurRo->ExecuteConstraint,
&writeFlag);
break;
case DRM_PERMISSION_PRINT:
flag =
drm_startConsumeRights(&pCurRo->bIsPrintable,
&pCurRo->PrintConstraint, &writeFlag);
break;
default:
free(pNumOfPriority);
free(pRo);
return DRM_FAILURE;
}
/* Here confirm the valid RO amount and set the writeFlag */
if (0 == pCurRo->bIsPlayable && 0 == pCurRo->bIsDisplayable &&
0 == pCurRo->bIsExecuteable && 0 == pCurRo->bIsPrintable) {
int32_t iCurPri;
/** refresh the right priority */
iCurPri = pNumOfPriority[i];
for(j = i; j < validRoAmount - 1; j++)
pNumOfPriority[j] = pNumOfPriority[j + 1];
if(iCurPri != validRoAmount - 1) {
memcpy(pCurRo, pRo + validRoAmount - 1,
sizeof(T_DRM_Rights));
for(j = 0; j < validRoAmount -1; j++) {
if(validRoAmount - 1 == pNumOfPriority[j])
pNumOfPriority[j] = iCurPri;
}
}
/* Here means it is not the last one RO, so the invalid RO should be deleted */
writeFlag = 1;
validRoAmount--; /* If current right is invalid */
i--;
}
/* If the flag is TRUE, this means: we have found a valid RO, so break, no need to check other RO */
if (DRM_SUCCESS == flag)
break;
}
if (1 == writeFlag) {
/* Delete the *.info first */
//drm_removeIdInfoFile(id);
if (FALSE == drm_writeOrReadInfo(id, pRo, &validRoAmount, SAVE_ALL_RO))
flag = DRM_FAILURE;
}
free(pNumOfPriority);
free(pRo);
return flag;
}
/* see svc_drm.h */
int32_t SVC_drm_installRights(T_DRM_Input_Data data, T_DRM_Rights_Info* pRightsInfo)
{
uint8_t *buf;
int32_t dataLen, bufLen;
T_DRM_Rights rights;
if (0 == data.inputHandle)
return DRM_RIGHTS_DATA_INVALID;
/* Get input rights data length */
dataLen = data.getInputDataLength(data.inputHandle);
if (dataLen <= 0)
return DRM_RIGHTS_DATA_INVALID;
/* Check if the length is larger than DRM max malloc length */
if (dataLen > DRM_MAX_MALLOC_LEN)
bufLen = DRM_MAX_MALLOC_LEN;
else
bufLen = dataLen;
buf = (uint8_t *)malloc(bufLen);
if (NULL == buf)
return DRM_FAILURE;
/* Read input data to buffer */
if (0 >= data.readInputData(data.inputHandle, buf, bufLen)) {
free(buf);
return DRM_RIGHTS_DATA_INVALID;
}
/* if the input mime type is unknown, DRM engine will try to recognize it. */
if (TYPE_DRM_UNKNOWN == data.mimeType)
data.mimeType = getMimeType(buf, bufLen);
switch(data.mimeType) {
case TYPE_DRM_MESSAGE: /* in case of Combined Delivery, extract the rights part to install */
{
T_DRM_DM_Info dmInfo;
memset(&dmInfo, 0, sizeof(T_DRM_DM_Info));
if (FALSE == drm_parseDM(buf, bufLen, &dmInfo)) {
free(buf);
return DRM_RIGHTS_DATA_INVALID;
}
/* if it is not Combined Delivery, it can not use to "SVC_drm_installRights" */
if (COMBINED_DELIVERY != dmInfo.deliveryType || dmInfo.rightsOffset <= 0 || dmInfo.rightsLen <= 0) {
free(buf);
return DRM_RIGHTS_DATA_INVALID;
}
memset(&rights, 0, sizeof(T_DRM_Rights));
if (FALSE == drm_relParser(buf + dmInfo.rightsOffset, dmInfo.rightsLen, TYPE_DRM_RIGHTS_XML, &rights)) {
free(buf);
return DRM_RIGHTS_DATA_INVALID;
}
}
break;
case TYPE_DRM_RIGHTS_XML:
case TYPE_DRM_RIGHTS_WBXML:
memset(&rights, 0, sizeof(T_DRM_Rights));
if (FALSE == drm_relParser(buf, bufLen, data.mimeType, &rights)) {
free(buf);
return DRM_RIGHTS_DATA_INVALID;
}
break;
case TYPE_DRM_CONTENT: /* DCF should not using "SVC_drm_installRights", it should be used to open a session. */
case TYPE_DRM_UNKNOWN:
default:
free(buf);
return DRM_MEDIA_DATA_INVALID;
}
free(buf);
/* append the rights information to DRM engine storage */
if (FALSE == drm_appendRightsInfo(&rights))
return DRM_FAILURE;
memset(pRightsInfo, 0, sizeof(T_DRM_Rights_Info));
drm_getLicenseInfo(&rights, pRightsInfo);
return DRM_SUCCESS;
}
/* see svc_drm.h */
int32_t SVC_drm_openSession(T_DRM_Input_Data data)
{
int32_t session;
int32_t dataLen;
T_DRM_Session_Node* s;
if (0 == data.inputHandle)
return DRM_MEDIA_DATA_INVALID;
/* Get input data length */
dataLen = data.getInputDataLength(data.inputHandle);
if (dataLen <= 0)
return DRM_MEDIA_DATA_INVALID;
s = newSession(data);
if (NULL == s)
return DRM_FAILURE;
/* Check if the length is larger than DRM max malloc length */
if (dataLen > DRM_MAX_MALLOC_LEN)
s->rawContentLen = DRM_MAX_MALLOC_LEN;
else
s->rawContentLen = dataLen;
s->rawContent = (uint8_t *)malloc(s->rawContentLen);
if (NULL == s->rawContent)
return DRM_FAILURE;
/* Read input data to buffer */
if (0 >= data.readInputData(data.inputHandle, s->rawContent, s->rawContentLen)) {
freeSession(s);
return DRM_MEDIA_DATA_INVALID;
}
/* if the input mime type is unknown, DRM engine will try to recognize it. */
if (TYPE_DRM_UNKNOWN == data.mimeType)
data.mimeType = getMimeType(s->rawContent, s->rawContentLen);
switch(data.mimeType) {
case TYPE_DRM_MESSAGE:
{
T_DRM_DM_Info dmInfo;
memset(&dmInfo, 0, sizeof(T_DRM_DM_Info));
if (FALSE == drm_parseDM(s->rawContent, s->rawContentLen, &dmInfo)) {
freeSession(s);
return DRM_MEDIA_DATA_INVALID;
}
s->deliveryMethod = dmInfo.deliveryType;
if (SEPARATE_DELIVERY_FL == s->deliveryMethod)
s->contentLength = DRM_UNKNOWN_DATA_LEN;
else
s->contentLength = dmInfo.contentLen;
s->transferEncoding = dmInfo.transferEncoding;
s->contentOffset = dmInfo.contentOffset;
s->bEndData = FALSE;
strcpy((char *)s->contentType, (char *)dmInfo.contentType);
strcpy((char *)s->contentID, (char *)dmInfo.contentID);
if (SEPARATE_DELIVERY_FL == s->deliveryMethod) {
s->infoStruct = (T_DRM_Dcf_Node *)malloc(sizeof(T_DRM_Dcf_Node));
if (NULL == s->infoStruct)
return DRM_FAILURE;
memset(s->infoStruct, 0, sizeof(T_DRM_Dcf_Node));
((T_DRM_Dcf_Node *)(s->infoStruct))->encContentLength = dmInfo.contentLen;
strcpy((char *)((T_DRM_Dcf_Node *)(s->infoStruct))->rightsIssuer, (char *)dmInfo.rightsIssuer);
break;
}
if (DRM_MESSAGE_CODING_BASE64 == s->transferEncoding) {
s->infoStruct = (T_DRM_DM_Base64_Node *)malloc(sizeof(T_DRM_DM_Base64_Node));
if (NULL == s->infoStruct)
return DRM_FAILURE;
memset(s->infoStruct, 0, sizeof(T_DRM_DM_Base64_Node));
strcpy((char *)((T_DRM_DM_Base64_Node *)(s->infoStruct))->boundary, (char *)dmInfo.boundary);
} else {
s->infoStruct = (T_DRM_DM_Binary_Node *)malloc(sizeof(T_DRM_DM_Binary_Node));
if (NULL == s->infoStruct)
return DRM_FAILURE;
memset(s->infoStruct, 0, sizeof(T_DRM_DM_Binary_Node));
strcpy((char *)((T_DRM_DM_Binary_Node *)(s->infoStruct))->boundary, (char *)dmInfo.boundary);
}
if (DRM_MESSAGE_CODING_BASE64 == s->transferEncoding) {
if (s->contentLength > 0) {
int32_t encLen, decLen;
encLen = s->contentLength;
decLen = encLen / DRM_B64_ENC_BLOCK * DRM_B64_DEC_BLOCK;
decLen = drm_decodeBase64(s->rawContent, decLen, s->rawContent + s->contentOffset, &encLen);
s->contentLength = decLen;
} else {
int32_t encLen = DRM_MAX_MALLOC_LEN - s->contentOffset, decLen;
int32_t skipLen, needBytes, i;
uint8_t *pStart;
int32_t res, bFoundBoundary = FALSE;
pStart = s->rawContent + s->contentOffset;
if (-1 == (skipLen = drm_skipCRLFinB64(pStart, encLen))) {
freeSession(s);
return DRM_FAILURE;
}
needBytes = DRM_B64_ENC_BLOCK - ((encLen - skipLen) % DRM_B64_ENC_BLOCK);
if (needBytes < DRM_B64_ENC_BLOCK) {
s->rawContent = (uint8_t *)realloc(s->rawContent, DRM_MAX_MALLOC_LEN + needBytes);
if (NULL == s->rawContent) {
freeSession(s);
return DRM_FAILURE;
}
i = 0;
while (i < needBytes) {
if (-1 != data.readInputData(data.inputHandle, s->rawContent + DRM_MAX_MALLOC_LEN + i, 1)) {
if ('\r' == *(s->rawContent + DRM_MAX_MALLOC_LEN + i) || '\n' == *(s->rawContent + DRM_MAX_MALLOC_LEN + i))
continue;
i++;
} else
break;
}
encLen += i;
}
res = drm_scanEndBoundary(pStart, encLen, ((T_DRM_DM_Base64_Node *)(s->infoStruct))->boundary);
if (-1 == res) {
freeSession(s);
return DRM_FAILURE;
}
if (-2 == res) { /* may be there is a boundary */
int32_t boundaryLen, leftLen, readBytes;
char* pTmp = memrchr(pStart, '\r', encLen);
if (NULL == pTmp) {
freeSession(s);
return DRM_FAILURE; /* conflict */
}
boundaryLen = strlen((char *)((T_DRM_DM_Base64_Node *)(s->infoStruct))->boundary) + 2; /* 2 means: '\r''\n' */
s->readBuf = (uint8_t *)malloc(boundaryLen);
if (NULL == s->readBuf) {
freeSession(s);
return DRM_FAILURE;
}
s->readBufOff = encLen - ((uint8_t *)pTmp - pStart);
s->readBufLen = boundaryLen - s->readBufOff;
memcpy(s->readBuf, pTmp, s->readBufOff);
readBytes = data.readInputData(data.inputHandle, s->readBuf + s->readBufOff, s->readBufLen);
if (-1 == readBytes || readBytes < s->readBufLen) {
freeSession(s);
return DRM_MEDIA_DATA_INVALID;
}
if (0 == drm_scanEndBoundary(s->readBuf, boundaryLen, ((T_DRM_DM_Base64_Node *)(s->infoStruct))->boundary)) {
encLen = (uint8_t *)pTmp - pStart; /* yes, it is the end boundary */
bFoundBoundary = TRUE;
}
} else {
if (res >= 0 && res < encLen) {
encLen = res;
bFoundBoundary = TRUE;
}
}
decLen = encLen / DRM_B64_ENC_BLOCK * DRM_B64_DEC_BLOCK;
decLen = drm_decodeBase64(s->rawContent, decLen, s->rawContent + s->contentOffset, &encLen);
((T_DRM_DM_Base64_Node *)(s->infoStruct))->b64DecodeDataLen = decLen;
if (bFoundBoundary)
s->contentLength = decLen;
}
} else {
/* binary data */
if (DRM_UNKNOWN_DATA_LEN == s->contentLength) {
/* try to check whether there is boundary may be split */
int32_t res, binContentLen;
uint8_t* pStart;
int32_t bFoundBoundary = FALSE;
pStart = s->rawContent + s->contentOffset;
binContentLen = s->rawContentLen - s->contentOffset;
res = drm_scanEndBoundary(pStart, binContentLen, ((T_DRM_DM_Binary_Node *)(s->infoStruct))->boundary);
if (-1 == res) {
freeSession(s);
return DRM_FAILURE;
}
if (-2 == res) { /* may be the boundary is split */
int32_t boundaryLen, leftLen, readBytes;
char* pTmp = memrchr(pStart, '\r', binContentLen);
if (NULL == pTmp) {
freeSession(s);
return DRM_FAILURE; /* conflict */
}
boundaryLen = strlen((char *)((T_DRM_DM_Binary_Node *)(s->infoStruct))->boundary) + 2; /* 2 means: '\r''\n' */
s->readBuf = (uint8_t *)malloc(boundaryLen);
if (NULL == s->readBuf) {
freeSession(s);
return DRM_FAILURE;
}
s->readBufOff = binContentLen - ((uint8_t *)pTmp - pStart);
s->readBufLen = boundaryLen - s->readBufOff;
memcpy(s->readBuf, pTmp, s->readBufOff);
readBytes = data.readInputData(data.inputHandle, s->readBuf + s->readBufOff, s->readBufLen);
if (-1 == readBytes || readBytes < s->readBufLen) {
freeSession(s);
return DRM_MEDIA_DATA_INVALID;
}
if (0 == drm_scanEndBoundary(s->readBuf, boundaryLen, ((T_DRM_DM_Binary_Node *)(s->infoStruct))->boundary)) {
binContentLen = (uint8_t *)pTmp - pStart; /* yes, it is the end boundary */
bFoundBoundary = TRUE;
}
} else {
if (res >= 0 && res < binContentLen) {
binContentLen = res;
bFoundBoundary = TRUE;
}
}
if (bFoundBoundary)
s->contentLength = binContentLen;
}
}
}
break;
case TYPE_DRM_CONTENT:
{
T_DRM_DCF_Info dcfInfo;
uint8_t* pEncData = NULL;
memset(&dcfInfo, 0, sizeof(T_DRM_DCF_Info));
if (FALSE == drm_dcfParser(s->rawContent, s->rawContentLen, &dcfInfo, &pEncData)) {
freeSession(s);
return DRM_MEDIA_DATA_INVALID;
}
s->infoStruct = (T_DRM_Dcf_Node *)malloc(sizeof(T_DRM_Dcf_Node));
if (NULL == s->infoStruct)
return DRM_FAILURE;
memset(s->infoStruct, 0, sizeof(T_DRM_Dcf_Node));
s->deliveryMethod = SEPARATE_DELIVERY;
s->contentLength = dcfInfo.DecryptedDataLen;
((T_DRM_Dcf_Node *)(s->infoStruct))->encContentLength = dcfInfo.EncryptedDataLen;
s->contentOffset = pEncData - s->rawContent;
strcpy((char *)s->contentType, (char *)dcfInfo.ContentType);
strcpy((char *)s->contentID, (char *)dcfInfo.ContentURI);
strcpy((char *)((T_DRM_Dcf_Node *)(s->infoStruct))->rightsIssuer, (char *)dcfInfo.Rights_Issuer);
}
break;
case TYPE_DRM_RIGHTS_XML: /* rights object should using "SVC_drm_installRights", it can not open a session */
case TYPE_DRM_RIGHTS_WBXML: /* rights object should using "SVC_drm_installRights", it can not open a session */
case TYPE_DRM_UNKNOWN:
default:
freeSession(s);
return DRM_MEDIA_DATA_INVALID;
}
if ((SEPARATE_DELIVERY_FL == s->deliveryMethod || SEPARATE_DELIVERY == s->deliveryMethod) &&
s->contentOffset + ((T_DRM_Dcf_Node *)(s->infoStruct))->encContentLength <= DRM_MAX_MALLOC_LEN) {
uint8_t keyValue[DRM_KEY_LEN];
uint8_t lastDcfBuf[DRM_TWO_AES_BLOCK_LEN];
int32_t seekPos, moreBytes;
if (TRUE == drm_getKey(s->contentID, keyValue)) {
seekPos = s->contentOffset + ((T_DRM_Dcf_Node *)(s->infoStruct))->encContentLength - DRM_TWO_AES_BLOCK_LEN;
memcpy(lastDcfBuf, s->rawContent + seekPos, DRM_TWO_AES_BLOCK_LEN);
if (TRUE == drm_updateDcfDataLen(lastDcfBuf, keyValue, &moreBytes)) {
s->contentLength = ((T_DRM_Dcf_Node *)(s->infoStruct))->encContentLength;
s->contentLength -= moreBytes;
}
}
}
session = addSession(s);
if (-1 == session)
return DRM_FAILURE;
return session;
}
/* see svc_drm.h */
int32_t SVC_drm_getDeliveryMethod(int32_t session)
{
T_DRM_Session_Node* s;
if (session < 0)
return DRM_FAILURE;
s = getSession(session);
if (NULL == s)
return DRM_SESSION_NOT_OPENED;
return s->deliveryMethod;
}
/* see svc_drm.h */
int32_t SVC_drm_getContentType(int32_t session, uint8_t* mediaType)
{
T_DRM_Session_Node* s;
if (session < 0 || NULL == mediaType)
return DRM_FAILURE;
s = getSession(session);
if (NULL == s)
return DRM_SESSION_NOT_OPENED;
strcpy((char *)mediaType, (char *)s->contentType);
return DRM_SUCCESS;
}
/* see svc_drm.h */
int32_t SVC_drm_checkRights(int32_t session, int32_t permission)
{
T_DRM_Session_Node* s;
int32_t id;
T_DRM_Rights *pRo, *pCurRo;
int32_t roAmount;
int32_t i;
int32_t res = DRM_FAILURE;
if (session < 0)
return DRM_FAILURE;
s = getSession(session);
if (NULL == s)
return DRM_SESSION_NOT_OPENED;
/* if it is Forward-Lock cases, check it and return directly */
if (FORWARD_LOCK == s->deliveryMethod) {
if (DRM_PERMISSION_PLAY == permission ||
DRM_PERMISSION_DISPLAY == permission ||
DRM_PERMISSION_EXECUTE == permission ||
DRM_PERMISSION_PRINT == permission)
return DRM_SUCCESS;
return DRM_FAILURE;
}
/* if try to forward, only DCF can be forwarded */
if (DRM_PERMISSION_FORWARD == permission) {
if (SEPARATE_DELIVERY == s->deliveryMethod)
return DRM_SUCCESS;
return DRM_FAILURE;
}
/* The following will check CD or SD other permissions */
if (FALSE == drm_readFromUidTxt(s->contentID, &id, GET_ID))
return DRM_FAILURE;
drm_writeOrReadInfo(id, NULL, &roAmount, GET_ROAMOUNT);
if (roAmount <= 0)
return DRM_FAILURE;
pRo = malloc(roAmount * sizeof(T_DRM_Rights));
if (NULL == pRo)
return DRM_FAILURE;
drm_writeOrReadInfo(id, pRo, &roAmount, GET_ALL_RO);
pCurRo = pRo;
for (i = 0; i < roAmount; i++) {
switch (permission) {
case DRM_PERMISSION_PLAY:
res = drm_startCheckRights(&(pCurRo->bIsPlayable), &(pCurRo->PlayConstraint));
break;
case DRM_PERMISSION_DISPLAY:
res = drm_startCheckRights(&(pCurRo->bIsDisplayable), &(pCurRo->DisplayConstraint));
break;
case DRM_PERMISSION_EXECUTE:
res = drm_startCheckRights(&(pCurRo->bIsExecuteable), &(pCurRo->ExecuteConstraint));
break;
case DRM_PERMISSION_PRINT:
res = drm_startCheckRights(&(pCurRo->bIsPrintable), &(pCurRo->PrintConstraint));
break;
default:
free(pRo);
return DRM_FAILURE;
}
if (DRM_SUCCESS == res) {
free(pRo);
return DRM_SUCCESS;
}
pCurRo++;
}
free(pRo);
return res;
}
/* see svc_drm.h */
int32_t SVC_drm_consumeRights(int32_t session, int32_t permission)
{
T_DRM_Session_Node* s;
int32_t id;
if (session < 0)
return DRM_FAILURE;
s = getSession(session);
if (NULL == s)
return DRM_SESSION_NOT_OPENED;
if (DRM_PERMISSION_FORWARD == permission) {
if (SEPARATE_DELIVERY == s->deliveryMethod)
return DRM_SUCCESS;
return DRM_FAILURE;
}
if (FORWARD_LOCK == s->deliveryMethod) /* Forwardlock type have utter rights */
return DRM_SUCCESS;
if (FALSE == drm_readFromUidTxt(s->contentID, &id, GET_ID))
return DRM_FAILURE;
return drm_checkRoAndUpdate(id, permission);
}
/* see svc_drm.h */
int32_t SVC_drm_getContentLength(int32_t session)
{
T_DRM_Session_Node* s;
if (session < 0)
return DRM_FAILURE;
s = getSession(session);
if (NULL == s)
return DRM_SESSION_NOT_OPENED;
if (DRM_UNKNOWN_DATA_LEN == s->contentLength && s->contentOffset + ((T_DRM_Dcf_Node *)(s->infoStruct))->encContentLength <= DRM_MAX_MALLOC_LEN &&
(SEPARATE_DELIVERY == s->deliveryMethod || SEPARATE_DELIVERY_FL == s->deliveryMethod)) {
uint8_t keyValue[DRM_KEY_LEN];
uint8_t lastDcfBuf[DRM_TWO_AES_BLOCK_LEN];
int32_t seekPos, moreBytes;
if (TRUE == drm_getKey(s->contentID, keyValue)) {
seekPos = s->contentOffset + ((T_DRM_Dcf_Node *)(s->infoStruct))->encContentLength - DRM_TWO_AES_BLOCK_LEN;
memcpy(lastDcfBuf, s->rawContent + seekPos, DRM_TWO_AES_BLOCK_LEN);
if (TRUE == drm_updateDcfDataLen(lastDcfBuf, keyValue, &moreBytes)) {
s->contentLength = ((T_DRM_Dcf_Node *)(s->infoStruct))->encContentLength;
s->contentLength -= moreBytes;
}
}
}
return s->contentLength;
}
static int32_t drm_readAesData(uint8_t* buf, T_DRM_Session_Node* s, int32_t aesStart, int32_t bufLen)
{
if (NULL == buf || NULL == s || aesStart < 0 || bufLen < 0)
return -1;
if (aesStart - s->contentOffset + bufLen > ((T_DRM_Dcf_Node *)(s->infoStruct))->encContentLength)
return -2;
if (aesStart < DRM_MAX_MALLOC_LEN) {
if (aesStart + bufLen <= DRM_MAX_MALLOC_LEN) { /* read from buffer */
memcpy(buf, s->rawContent + aesStart, bufLen);
return bufLen;
} else { /* first read from buffer and then from InputStream */
int32_t point = DRM_MAX_MALLOC_LEN - aesStart;
int32_t res;
if (((T_DRM_Dcf_Node *)(s->infoStruct))->bAesBackupBuf) {
memcpy(buf, ((T_DRM_Dcf_Node *)(s->infoStruct))->aesBackupBuf, DRM_ONE_AES_BLOCK_LEN);
res = s->readInputDataFunc(s->inputHandle, buf + DRM_ONE_AES_BLOCK_LEN, DRM_ONE_AES_BLOCK_LEN);
if (0 == res || -1 == res)
return -1;
res += DRM_ONE_AES_BLOCK_LEN;
} else {
memcpy(buf, s->rawContent + aesStart, point);
res = s->readInputDataFunc(s->inputHandle, buf + point, bufLen - point);
if (0 == res || -1 == res)
return -1;
res += point;
}
memcpy(((T_DRM_Dcf_Node *)(s->infoStruct))->aesBackupBuf, buf + DRM_ONE_AES_BLOCK_LEN, DRM_ONE_AES_BLOCK_LEN);
((T_DRM_Dcf_Node *)(s->infoStruct))->bAesBackupBuf = TRUE;
return res;
}
} else { /* read from InputStream */
int32_t res;
memcpy(buf, ((T_DRM_Dcf_Node *)(s->infoStruct))->aesBackupBuf, DRM_ONE_AES_BLOCK_LEN);
res = s->readInputDataFunc(s->inputHandle, buf + DRM_ONE_AES_BLOCK_LEN, DRM_ONE_AES_BLOCK_LEN);
if (0 == res || -1 == res)
return -1;
memcpy(((T_DRM_Dcf_Node *)(s->infoStruct))->aesBackupBuf, buf + DRM_ONE_AES_BLOCK_LEN, DRM_ONE_AES_BLOCK_LEN);
return DRM_ONE_AES_BLOCK_LEN + res;
}
}
static int32_t drm_readContentFromBuf(T_DRM_Session_Node* s, int32_t offset, uint8_t* mediaBuf, int32_t mediaBufLen)
{
int32_t readBytes;
if (offset > s->contentLength)
return DRM_FAILURE;
if (offset == s->contentLength)
return DRM_MEDIA_EOF;
if (offset + mediaBufLen > s->contentLength)
readBytes = s->contentLength - offset;
else
readBytes = mediaBufLen;
if (DRM_MESSAGE_CODING_BASE64 == s->transferEncoding)
memcpy(mediaBuf, s->rawContent + offset, readBytes);
else
memcpy(mediaBuf, s->rawContent + s->contentOffset + offset, readBytes);
return readBytes;
}
static int32_t drm_readB64ContentFromInputStream(T_DRM_Session_Node* s, int32_t offset, uint8_t* mediaBuf, int32_t mediaBufLen)
{
uint8_t encBuf[DRM_B64_ENC_BLOCK], decBuf[DRM_B64_DEC_BLOCK];
int32_t encLen, decLen;
int32_t i, j, piece, leftLen, firstBytes;
int32_t readBytes = 0;
if (offset < ((T_DRM_DM_Base64_Node *)(s->infoStruct))->b64DecodeDataLen) {
readBytes = ((T_DRM_DM_Base64_Node *)(s->infoStruct))->b64DecodeDataLen - offset;
memcpy(mediaBuf, s->rawContent + offset, readBytes);
} else {
if (s->bEndData)
return DRM_MEDIA_EOF;
firstBytes = offset % DRM_B64_DEC_BLOCK;
if (firstBytes > 0) {
if (DRM_B64_DEC_BLOCK - firstBytes >= mediaBufLen) {
readBytes = mediaBufLen;
memcpy(mediaBuf, ((T_DRM_DM_Base64_Node *)(s->infoStruct))->b64DecodeData + firstBytes, readBytes);
return readBytes;
}
readBytes = DRM_B64_DEC_BLOCK - firstBytes;
memcpy(mediaBuf, ((T_DRM_DM_Base64_Node *)(s->infoStruct))->b64DecodeData + firstBytes, readBytes);
}
}
leftLen = mediaBufLen - readBytes;
encLen = (leftLen - 1) / DRM_B64_DEC_BLOCK * DRM_B64_ENC_BLOCK + DRM_B64_ENC_BLOCK;
piece = encLen / DRM_B64_ENC_BLOCK;
for (i = 0; i < piece; i++) {
j = 0;
while (j < DRM_B64_ENC_BLOCK) {
if (NULL != s->readBuf && s->readBufLen > 0) { /* read from backup buffer */
*(encBuf + j) = s->readBuf[s->readBufOff];
s->readBufOff++;
s->readBufLen--;
} else { /* read from InputStream */
if (0 == s->readInputDataFunc(s->inputHandle, encBuf + j, 1))
return DRM_MEDIA_DATA_INVALID;
}
if ('\r' == *(encBuf + j) || '\n' == *(encBuf + j))
continue; /* skip CRLF */
if ('-' == *(encBuf + j)) {
int32_t k, len;
/* invalid base64 data, it comes to end boundary */
if (0 != j)
return DRM_MEDIA_DATA_INVALID;
/* check whether it is really the boundary */
len = strlen((char *)((T_DRM_DM_Base64_Node *)(s->infoStruct))->boundary);
if (NULL == s->readBuf) {
s->readBuf = (uint8_t *)malloc(len);
if (NULL == s->readBuf)
return DRM_FAILURE;
}
s->readBuf[0] = '-';
for (k = 0; k < len - 1; k++) {
if (NULL != s->readBuf && s->readBufLen > 0) { /* read from backup buffer */
*(s->readBuf + k + 1) = s->readBuf[s->readBufOff];
s->readBufOff++;
s->readBufLen--;
} else { /* read from InputStream */
if (-1 == s->readInputDataFunc(s->inputHandle, s->readBuf + k + 1, 1))
return DRM_MEDIA_DATA_INVALID;
}
}
if (0 == memcmp(s->readBuf, ((T_DRM_DM_Base64_Node *)(s->infoStruct))->boundary, len))
s->bEndData = TRUE;
else
return DRM_MEDIA_DATA_INVALID;
break;
}
j++;
}
if (TRUE == s->bEndData) { /* it means come to the end of base64 data */
if (0 == readBytes)
return DRM_MEDIA_EOF;
break;
}
encLen = DRM_B64_ENC_BLOCK;
decLen = DRM_B64_DEC_BLOCK;
if (-1 == (decLen = drm_decodeBase64(decBuf, decLen, encBuf, &encLen)))
return DRM_MEDIA_DATA_INVALID;
if (leftLen >= decLen) {
memcpy(mediaBuf + readBytes, decBuf, decLen);
readBytes += decLen;
leftLen -= decLen;
} else {
if (leftLen > 0) {
memcpy(mediaBuf + readBytes, decBuf, leftLen);
readBytes += leftLen;
}
break;
}
}
memcpy(((T_DRM_DM_Base64_Node *)(s->infoStruct))->b64DecodeData, decBuf, DRM_B64_DEC_BLOCK);
return readBytes;
}
static int32_t drm_readBase64Content(T_DRM_Session_Node* s, int32_t offset, uint8_t* mediaBuf, int32_t mediaBufLen)
{
int32_t readBytes;
/* when the content length has been well-known */
if (s->contentLength >= 0)
readBytes = drm_readContentFromBuf(s, offset, mediaBuf, mediaBufLen);
else /* else when the content length has not been well-known yet */
if (offset < ((T_DRM_DM_Base64_Node *)(s->infoStruct))->b64DecodeDataLen)
if (offset + mediaBufLen <= ((T_DRM_DM_Base64_Node *)(s->infoStruct))->b64DecodeDataLen) {
readBytes = mediaBufLen;
memcpy(mediaBuf, s->rawContent + offset, readBytes);
} else
readBytes = drm_readB64ContentFromInputStream(s, offset, mediaBuf, mediaBufLen);
else
readBytes = drm_readB64ContentFromInputStream(s, offset, mediaBuf, mediaBufLen);
return readBytes;
}
static int32_t drm_readBinaryContentFromInputStream(T_DRM_Session_Node* s, int32_t offset, uint8_t* mediaBuf, int32_t mediaBufLen)
{
int32_t res = 0, readBytes = 0;
int32_t leftLen;
if (s->contentOffset + offset < DRM_MAX_MALLOC_LEN) {
readBytes = DRM_MAX_MALLOC_LEN - s->contentOffset - offset;
memcpy(mediaBuf, s->rawContent + s->contentOffset + offset, readBytes);
} else
if (s->bEndData)
return DRM_MEDIA_EOF;
leftLen = mediaBufLen - readBytes;
if (NULL != s->readBuf && s->readBufLen > 0) { /* read from backup buffer */
if (leftLen <= s->readBufLen) {
memcpy(mediaBuf, s->readBuf + s->readBufOff, leftLen);
s->readBufOff += leftLen;
s->readBufLen -= leftLen;
readBytes += leftLen;
leftLen = 0;
} else {
memcpy(mediaBuf, s->readBuf + s->readBufOff, s->readBufLen);
s->readBufOff += s->readBufLen;
leftLen -= s->readBufLen;
readBytes += s->readBufLen;
s->readBufLen = 0;
}
}
if (leftLen > 0) {
res = s->readInputDataFunc(s->inputHandle, mediaBuf + readBytes, mediaBufLen - readBytes);
if (-1 == res)
return DRM_MEDIA_DATA_INVALID;
}
readBytes += res;
res = drm_scanEndBoundary(mediaBuf, readBytes, ((T_DRM_DM_Binary_Node *)(s->infoStruct))->boundary);
if (-1 == res)
return DRM_MEDIA_DATA_INVALID;
if (-2 == res) { /* may be the boundary is split */
int32_t boundaryLen, len, off, k;
char* pTmp = memrchr(mediaBuf, '\r', readBytes);
if (NULL == pTmp)
return DRM_FAILURE; /* conflict */
boundaryLen = strlen((char *)((T_DRM_DM_Binary_Node *)(s->infoStruct))->boundary) + 2; /* 2 means: '\r''\n' */
if (NULL == s->readBuf) {
s->readBuf = (uint8_t *)malloc(boundaryLen);
if (NULL == s->readBuf)
return DRM_FAILURE;
}
off = readBytes - ((uint8_t *)pTmp - mediaBuf);
len = boundaryLen - off;
memcpy(s->readBuf, pTmp, off);
for (k = 0; k < boundaryLen - off; k++) {
if (NULL != s->readBuf && s->readBufLen > 0) { /* read from backup buffer */
*(s->readBuf + k + off) = s->readBuf[s->readBufOff];
s->readBufOff++;
s->readBufLen--;
} else { /* read from InputStream */
if (-1 == s->readInputDataFunc(s->inputHandle, s->readBuf + k + off, 1))
return DRM_MEDIA_DATA_INVALID;
}
}
s->readBufOff = off;
s->readBufLen = len;
if (0 == drm_scanEndBoundary(s->readBuf, boundaryLen, ((T_DRM_DM_Binary_Node *)(s->infoStruct))->boundary)) {
readBytes = (uint8_t *)pTmp - mediaBuf; /* yes, it is the end boundary */
s->bEndData = TRUE;
}
} else {
if (res >= 0 && res < readBytes) {
readBytes = res;
s->bEndData = TRUE;
}
}
if (s->bEndData) {
if (0 == readBytes)
return DRM_MEDIA_EOF;
}
return readBytes;
}
static int32_t drm_readBinaryContent(T_DRM_Session_Node* s, int32_t offset, uint8_t* mediaBuf, int32_t mediaBufLen)
{
int32_t readBytes;
if (s->contentLength >= 0)
readBytes = drm_readContentFromBuf(s, offset, mediaBuf, mediaBufLen);
else /* else when the content length has not been well-known yet */
if (s->contentOffset + offset < DRM_MAX_MALLOC_LEN)
if (s->contentOffset + offset + mediaBufLen <= DRM_MAX_MALLOC_LEN) {
readBytes = mediaBufLen;
memcpy(mediaBuf, s->rawContent + s->contentOffset + offset, readBytes);
} else
readBytes = drm_readBinaryContentFromInputStream(s, offset, mediaBuf, mediaBufLen);
else
readBytes = drm_readBinaryContentFromInputStream(s, offset, mediaBuf, mediaBufLen);
return readBytes;
}
static int32_t drm_readAesContent(T_DRM_Session_Node* s, int32_t offset, uint8_t* mediaBuf, int32_t mediaBufLen)
{
uint8_t keyValue[DRM_KEY_LEN];
uint8_t buf[DRM_TWO_AES_BLOCK_LEN];
int32_t readBytes = 0;
int32_t bufLen, piece, i, copyBytes, leftBytes;
int32_t aesStart, mediaStart, mediaBufOff;
AES_KEY key;
if (FALSE == drm_getKey(s->contentID, keyValue))
return DRM_NO_RIGHTS;
/* when the content length has been well-known */
if (s->contentLength > 0) {
if (offset > s->contentLength)
return DRM_FAILURE;
if (offset == s->contentLength)
return DRM_MEDIA_EOF;
if (offset + mediaBufLen > s->contentLength)
readBytes = s->contentLength - offset;
else
readBytes = mediaBufLen;
aesStart = s->contentOffset + (offset / DRM_ONE_AES_BLOCK_LEN * DRM_ONE_AES_BLOCK_LEN);
piece = (offset + readBytes - 1) / DRM_ONE_AES_BLOCK_LEN - offset / DRM_ONE_AES_BLOCK_LEN + 2;
mediaStart = offset % DRM_ONE_AES_BLOCK_LEN;
AES_set_decrypt_key(keyValue, DRM_KEY_LEN * 8, &key);
mediaBufOff = 0;
leftBytes = readBytes;
for (i = 0; i < piece - 1; i++) {
memcpy(buf, s->rawContent + aesStart + i * DRM_ONE_AES_BLOCK_LEN, DRM_TWO_AES_BLOCK_LEN);
bufLen = DRM_TWO_AES_BLOCK_LEN;
if (drm_aesDecBuffer(buf, &bufLen, &key) < 0)
return DRM_MEDIA_DATA_INVALID;
if (0 != i)
mediaStart = 0;
if (bufLen - mediaStart <= leftBytes)
copyBytes = bufLen - mediaStart;
else
copyBytes = leftBytes;
memcpy(mediaBuf + mediaBufOff, buf + mediaStart, copyBytes);
leftBytes -= copyBytes;
mediaBufOff += copyBytes;
}
} else {
int32_t res;
if (s->bEndData)
return DRM_MEDIA_EOF;
if (((T_DRM_Dcf_Node *)(s->infoStruct))->aesDecDataLen > ((T_DRM_Dcf_Node *)(s->infoStruct))->aesDecDataOff) {
if (mediaBufLen < ((T_DRM_Dcf_Node *)(s->infoStruct))->aesDecDataLen - ((T_DRM_Dcf_Node *)(s->infoStruct))->aesDecDataOff)
copyBytes = mediaBufLen;
else
copyBytes = ((T_DRM_Dcf_Node *)(s->infoStruct))->aesDecDataLen - ((T_DRM_Dcf_Node *)(s->infoStruct))->aesDecDataOff;
memcpy(mediaBuf, ((T_DRM_Dcf_Node *)(s->infoStruct))->aesDecData + ((T_DRM_Dcf_Node *)(s->infoStruct))->aesDecDataOff, copyBytes);
((T_DRM_Dcf_Node *)(s->infoStruct))->aesDecDataOff += copyBytes;
readBytes += copyBytes;
}
leftBytes = mediaBufLen - readBytes;
if (0 == leftBytes)
return readBytes;
if (leftBytes < 0)
return DRM_FAILURE;
offset += readBytes;
aesStart = s->contentOffset + (offset / DRM_ONE_AES_BLOCK_LEN * DRM_ONE_AES_BLOCK_LEN);
piece = (offset + leftBytes - 1) / DRM_ONE_AES_BLOCK_LEN - offset / DRM_ONE_AES_BLOCK_LEN + 2;
mediaBufOff = readBytes;
AES_set_decrypt_key(keyValue, DRM_KEY_LEN * 8, &key);
for (i = 0; i < piece - 1; i++) {
if (-1 == (res = drm_readAesData(buf, s, aesStart, DRM_TWO_AES_BLOCK_LEN)))
return DRM_MEDIA_DATA_INVALID;
if (-2 == res)
break;
bufLen = DRM_TWO_AES_BLOCK_LEN;
aesStart += DRM_ONE_AES_BLOCK_LEN;
if (drm_aesDecBuffer(buf, &bufLen, &key) < 0)
return DRM_MEDIA_DATA_INVALID;
drm_discardPaddingByte(buf, &bufLen);
if (bufLen <= leftBytes)
copyBytes = bufLen;
else
copyBytes = leftBytes;
memcpy(mediaBuf + mediaBufOff, buf, copyBytes);
leftBytes -= copyBytes;
mediaBufOff += copyBytes;
readBytes += copyBytes;
}
memcpy(((T_DRM_Dcf_Node *)(s->infoStruct))->aesDecData, buf, DRM_ONE_AES_BLOCK_LEN);
((T_DRM_Dcf_Node *)(s->infoStruct))->aesDecDataLen = bufLen;
((T_DRM_Dcf_Node *)(s->infoStruct))->aesDecDataOff = copyBytes;
if (aesStart - s->contentOffset > ((T_DRM_Dcf_Node *)(s->infoStruct))->encContentLength - DRM_TWO_AES_BLOCK_LEN && ((T_DRM_Dcf_Node *)(s->infoStruct))->aesDecDataOff == ((T_DRM_Dcf_Node *)(s->infoStruct))->aesDecDataLen) {
s->bEndData = TRUE;
if (0 == readBytes)
return DRM_MEDIA_EOF;
}
}
return readBytes;
}
/* see svc_drm.h */
int32_t SVC_drm_getContent(int32_t session, int32_t offset, uint8_t* mediaBuf, int32_t mediaBufLen)
{
T_DRM_Session_Node* s;
int32_t readBytes;
if (session < 0 || offset < 0 || NULL == mediaBuf || mediaBufLen <= 0)
return DRM_FAILURE;
s = getSession(session);
if (NULL == s)
return DRM_SESSION_NOT_OPENED;
if (0 >= s->getInputDataLengthFunc(s->inputHandle))
return DRM_MEDIA_DATA_INVALID;
switch(s->deliveryMethod) {
case FORWARD_LOCK:
case COMBINED_DELIVERY:
if (DRM_MESSAGE_CODING_BASE64 == s->transferEncoding)
readBytes = drm_readBase64Content(s, offset, mediaBuf, mediaBufLen);
else /* binary */
readBytes = drm_readBinaryContent(s, offset, mediaBuf, mediaBufLen);
break;
case SEPARATE_DELIVERY:
case SEPARATE_DELIVERY_FL:
readBytes = drm_readAesContent(s, offset, mediaBuf, mediaBufLen);
break;
default:
return DRM_FAILURE;
}
return readBytes;
}
/* see svc_drm.h */
int32_t SVC_drm_getRightsIssuer(int32_t session, uint8_t* rightsIssuer)
{
T_DRM_Session_Node* s;
if (session < 0 || NULL == rightsIssuer)
return DRM_FAILURE;
s = getSession(session);
if (NULL == s)
return DRM_SESSION_NOT_OPENED;
if (SEPARATE_DELIVERY == s->deliveryMethod || SEPARATE_DELIVERY_FL == s->deliveryMethod) {
strcpy((char *)rightsIssuer, (char *)((T_DRM_Dcf_Node *)(s->infoStruct))->rightsIssuer);
return DRM_SUCCESS;
}
return DRM_NOT_SD_METHOD;
}
/* see svc_drm.h */
int32_t SVC_drm_getRightsInfo(int32_t session, T_DRM_Rights_Info* rights)
{
T_DRM_Session_Node* s;
T_DRM_Rights rightsInfo;
int32_t roAmount, id;
if (session < 0 || NULL == rights)
return DRM_FAILURE;
s = getSession(session);
if (NULL == s)
return DRM_SESSION_NOT_OPENED;
if (FORWARD_LOCK == s->deliveryMethod) {
strcpy((char *)rights->roId, "ForwardLock");
rights->displayRights.indicator = DRM_NO_CONSTRAINT;
rights->playRights.indicator = DRM_NO_CONSTRAINT;
rights->executeRights.indicator = DRM_NO_CONSTRAINT;
rights->printRights.indicator = DRM_NO_CONSTRAINT;
return DRM_SUCCESS;
}
if (FALSE == drm_readFromUidTxt(s->contentID, &id, GET_ID))
return DRM_NO_RIGHTS;
if (FALSE == drm_writeOrReadInfo(id, NULL, &roAmount, GET_ROAMOUNT))
return DRM_FAILURE;
if (roAmount < 0)
return DRM_NO_RIGHTS;
/* some rights has been installed, but now there is no valid rights */
if (0 == roAmount) {
strcpy((char *)rights->roId, s->contentID);
rights->displayRights.indicator = DRM_NO_PERMISSION;
rights->playRights.indicator = DRM_NO_PERMISSION;
rights->executeRights.indicator = DRM_NO_PERMISSION;
rights->printRights.indicator = DRM_NO_PERMISSION;
return DRM_SUCCESS;
}
roAmount = 1;
memset(&rightsInfo, 0, sizeof(T_DRM_Rights));
if (FALSE == drm_writeOrReadInfo(id, &rightsInfo, &roAmount, GET_A_RO))
return DRM_FAILURE;
memset(rights, 0, sizeof(T_DRM_Rights_Info));
drm_getLicenseInfo(&rightsInfo, rights);
return DRM_SUCCESS;
}
/* see svc_drm.h */
int32_t SVC_drm_closeSession(int32_t session)
{
if (session < 0)
return DRM_FAILURE;
if (NULL == getSession(session))
return DRM_SESSION_NOT_OPENED;
removeSession(session);
return DRM_SUCCESS;
}
/* see svc_drm.h */
int32_t SVC_drm_updateRights(uint8_t* contentID, int32_t permission)
{
int32_t id;
if (NULL == contentID)
return DRM_FAILURE;
if (FALSE == drm_readFromUidTxt(contentID, &id, GET_ID))
return DRM_FAILURE;
return drm_checkRoAndUpdate(id, permission);
}
/* see svc_drm.h */
int32_t SVC_drm_viewAllRights(T_DRM_Rights_Info_Node **ppRightsInfo)
{
T_DRM_Rights_Info_Node rightsNode;
int32_t maxId, id, roAmount, j;
T_DRM_Rights rights;
memset(&rights, 0, sizeof(T_DRM_Rights));
if (NULL == ppRightsInfo)
return DRM_FAILURE;
*ppRightsInfo = NULL;
maxId = drm_getMaxIdFromUidTxt();
if (-1 == maxId)
return DRM_FAILURE;
for (id = 1; id <= maxId; id++) {
drm_writeOrReadInfo(id, NULL, &roAmount, GET_ROAMOUNT);
if (roAmount <= 0) /* this means there is not any rights */
continue;
for (j = 1; j <= roAmount; j++) {
if (FALSE == drm_writeOrReadInfo(id, &rights, &j, GET_A_RO))
continue;
memset(&rightsNode, 0, sizeof(T_DRM_Rights_Info_Node));
drm_getLicenseInfo(&rights, &(rightsNode.roInfo));
if (FALSE == drm_addRightsNodeToList(ppRightsInfo, &rightsNode))
continue;
}
}
return DRM_SUCCESS;
}
/* see svc_drm.h */
int32_t SVC_drm_freeRightsInfoList(T_DRM_Rights_Info_Node *pRightsHeader)
{
T_DRM_Rights_Info_Node *pNode, *pTmp;
if (NULL == pRightsHeader)
return DRM_FAILURE;
pNode = pRightsHeader;
while (NULL != pNode) {
pTmp = pNode;
pNode = pNode->next;
free(pTmp);
}
return DRM_SUCCESS;
}
/* see svc_drm.h */
int32_t SVC_drm_deleteRights(uint8_t* roId)
{
int32_t maxId, id, roAmount, j;
T_DRM_Rights rights;
memset(&rights, 0, sizeof(T_DRM_Rights));
if (NULL == roId)
return DRM_FAILURE;
maxId = drm_getMaxIdFromUidTxt();
if (-1 == maxId)
return DRM_NO_RIGHTS;
for (id = 1; id <= maxId; id++) {
drm_writeOrReadInfo(id, NULL, &roAmount, GET_ROAMOUNT);
if (roAmount <= 0) /* this means there is not any rights */
continue;
for (j = 1; j <= roAmount; j++) {
if (FALSE == drm_writeOrReadInfo(id, &rights, &j, GET_A_RO))
continue;
/* here find the RO which will be deleted */
if (0 == strcmp((char *)rights.uid, (char *)roId)) {
T_DRM_Rights *pAllRights;
pAllRights = (T_DRM_Rights *)malloc(roAmount * sizeof(T_DRM_Rights));
if (NULL == pAllRights)
return DRM_FAILURE;
drm_writeOrReadInfo(id, pAllRights, &roAmount, GET_ALL_RO);
roAmount--;
if (0 == roAmount) { /* this means it is the last one rights */
drm_removeIdInfoFile(id); /* delete the id.info file first */
drm_updateUidTxtWhenDelete(id); /* update uid.txt file */
free(pAllRights);
return DRM_SUCCESS;
} else /* using the last one rights instead of the deleted one */
memcpy(pAllRights + (j - 1), pAllRights + roAmount, sizeof(T_DRM_Rights));
/* delete the id.info file first */
// drm_removeIdInfoFile(id);
if (FALSE == drm_writeOrReadInfo(id, pAllRights, &roAmount, SAVE_ALL_RO)) {
free(pAllRights);
return DRM_FAILURE;
}
free(pAllRights);
return DRM_SUCCESS;
}
}
}
return DRM_FAILURE;
}