/*
 * 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 <aes.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_decrypt_ctx ctx[1];

    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_decrypt_key128(keyValue, ctx);
        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, ctx) < 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_decrypt_key128(keyValue, ctx);

        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, ctx) < 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;
}
