utils/MsgDrmWrapper.cpp

   1 /*
   2 *
   3 * Copyright (c) 2000-2012 Samsung Electronics Co., Ltd. All Rights Reserved.
   4 *
   5 * This file is part of msg-service.
   6 *
   7 * Contact: Jaeyun Jeong <jyjeong@samsung.com>
   8 *          Sangkoo Kim <sangkoo.kim@samsung.com>
   9 *          Seunghwan Lee <sh.cat.lee@samsung.com>
  10 *          SoonMin Jung <sm0415.jung@samsung.com>
  11 *          Jae-Young Lee <jy4710.lee@samsung.com>
  12 *          KeeBum Kim <keebum.kim@samsung.com>
  13 *
  14 * PROPRIETARY/CONFIDENTIAL
  15 *
  16 * This software is the confidential and proprietary information of
  17 * SAMSUNG ELECTRONICS ("Confidential Information"). You shall not
  18 * disclose such Confidential Information and shall use it only in
  19 * accordance with the terms of the license agreement you entered
  20 * into with SAMSUNG ELECTRONICS.
  21 *
  22 * SAMSUNG make no representations or warranties about the suitability
  23 * of the software, either express or implied, including but not limited
  24 * to the implied warranties of merchantability, fitness for a particular
  25 * purpose, or non-infringement. SAMSUNG shall not be liable for any
  26 * damages suffered by licensee as a result of using, modifying or
  27 * distributing this software or its derivatives.
  28 *
  29 */
  30
  31 #include "MsgDebug.h"
  32 #include "MsgDrmWrapper.h"
  33 #include "MsgUtilFile.h"
  34
  35 #include <assert.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <dirent.h>
  39 #include <string.h>
  40 #include <sys/vfs.h>
  41 #include <sys/types.h>
  42 #include <sys/stat.h>
  43
  44 #include <fcntl.h>
  45 #include <unistd.h>
  46 #include <errno.h>
  47 #include "drm-service.h"
  48
  49
  50 typedef struct {
  51         DRM_RIGHTS_CONSUME_HANDLE hRightsConsume;
  52         MSG_DRM_TYPE eDRMType; //to have a drm type
  53         char *szOpenedDRMFileName;
  54 } MSG_OPENEDDRM_INFO_T;
  55
  56
  57 #define MSG_MAX_DRM_FILE_PATH MSG_FILEPATH_LEN_MAX
  58
  59
  60 bool MsgDrmRegisterFile(MSG_DRM_OPENMODE eMode, char *pBuffer, int nSize)
  61 {
  62         if (eMode == MSG_MODE_STREAM) {
  63                 MSG_DEBUG("Fail(eMode == MSG_MODE_STREAM)");
  64                 return false;
  65         }
  66
  67         if (pBuffer == NULL) {
  68                 MSG_DEBUG("[Error] pBuffer is NULL");
  69                 return false;
  70         }
  71
  72         MSG_DEBUG("buffer = %s, nSize = %d", pBuffer, nSize);
  73
  74         if (!drm_svc_is_drm_file(pBuffer)) {    // Check whether DRM file or not
  75                 MSG_DEBUG("file is not drm file");
  76                 return false;
  77         }
  78
  79         DRM_RESULT eDRMResult = drm_svc_register_file(pBuffer); // Register a DCF file
  80         if (DRM_RESULT_SUCCESS != eDRMResult) {
  81                 MSG_DEBUG("drm_svc_register_file is failed : %d", eDRMResult);
  82                 return false;
  83         }
  84
  85         return true;
  86 }
  87
  88 bool MsgDrmUnregisterFile(char *szFilename)
  89 {
  90         if (szFilename == NULL) {
  91                 MSG_DEBUG("[Error] szFilename is NULL");
  92                 return false;
  93         }
  94
  95         MSG_DEBUG("szFilename = %s", szFilename);
  96
  97         DRM_RESULT eDRMResult = drm_svc_unregister_file(szFilename, DRM_TRUE); // Unregister a DCF file
  98         if (DRM_RESULT_SUCCESS != eDRMResult) {
  99                 MSG_DEBUG("drm_svc_unregister_file : %d", eDRMResult);
 100                 return false;
 101         }
 102
 103         return true;
 104 }
 105
 106 bool MsgDrmIsDrmFile(const char *szFilePath)
 107 {
 108         if (drm_svc_is_drm_file(szFilePath) == DRM_FALSE) {
 109                 MSG_DEBUG("file is not drm file");
 110                 return false;
 111         }
 112
 113         return true;
 114 }
 115
 116 /*Added to convert the .dm files in to .dcf files since our platform supports only .dcf :: Start*/
 117 bool MsgDrmConvertDmtoDcfType(char *inputFile, char *outputFile)
 118 {
 119         if ((NULL == inputFile) || (NULL == outputFile)) {
 120                 MSG_DEBUG("Invalid Input parameters");
 121                 return false;
 122         }
 123
 124         if (strstr(inputFile, ".dm")) {
 125                 MSG_DEBUG("Current File extension is .dm %s", inputFile);
 126                 DRM_RESULT ret;
 127                 DRM_CONVERT_HANDLE hConvert = NULL;
 128                 unsigned long written;
 129
 130                 FILE *fp = MsgOpenFile(inputFile, "rb");//Check fp
 131
 132                 if (fp == NULL) {
 133                         MSG_DEBUG("[File Open Fail(Errno=%d)][ErrStr=%s]", errno, strerror(errno));
 134                         strncpy(outputFile, inputFile, MSG_MAX_DRM_FILE_PATH);
 135                         return false;
 136                 }
 137
 138                 if (MsgFseek(fp, 0L, SEEK_END) < 0) {
 139                         MsgCloseFile(fp);
 140                         MSG_DEBUG("MsgFseek() returns negative value!!!");
 141                         return false;
 142                 }
 143                 long retVal = MsgFtell(fp);
 144
 145                 if (retVal < 0) {
 146                         MsgCloseFile(fp);
 147                         MSG_DEBUG("ftell() returns negative value: [%ld]!!!", retVal);
 148                         strncpy(outputFile, inputFile, MSG_MAX_DRM_FILE_PATH);
 149                         return false;
 150                 }
 151
 152                 unsigned long bufLen = retVal;
 153                 MSG_DEBUG("fopen buffer len = %d", bufLen);
 154                 if (MsgFseek(fp, 0, SEEK_SET) < 0) {
 155                         MsgCloseFile(fp);
 156                         MSG_DEBUG("MsgFseek() returns negative value!!!");
 157                         return false;
 158                 }
 159
 160                 char *buffer = (char *)malloc(bufLen);
 161                 int readed_size = 0;
 162                 int pathLen = strlen(inputFile);
 163
 164                 if (buffer == NULL) {
 165                         MsgCloseFile(fp);
 166                         MSG_DEBUG("malloc is failed ");
 167                         strncpy(outputFile, inputFile, MSG_MAX_DRM_FILE_PATH);
 168                         return false;
 169                 }
 170
 171                 strncpy(outputFile, inputFile, pathLen - 2);
 172                 strncat(outputFile, "dcf", 3);
 173
 174                 readed_size = MsgReadFile(buffer, 1, bufLen, fp);//Check for error
 175                 MSG_DEBUG("fread read size = %d", readed_size);
 176                 if (readed_size == 0) {
 177                         MsgCloseFile(fp);
 178                         free(buffer);
 179                         MSG_DEBUG("MsgReadFile returns 0");
 180                         return false;
 181                 }
 182
 183                 ret = drm_svc_open_convert(outputFile, DRM_TRUE, &hConvert);//Check return value
 184                 if (ret != DRM_RESULT_SUCCESS) {
 185                         free(buffer);
 186                         MsgCloseFile(fp);
 187                         MSG_DEBUG("drm_svc_open_convert() return = failed (%d)", ret);
 188                         strncpy(outputFile, inputFile, MSG_MAX_DRM_FILE_PATH);
 189                         return false;
 190                 }
 191
 192                 /*We can call drm_svc_write_convert in loop if file size is large*/
 193                 ret = drm_svc_write_convert(hConvert, (unsigned char *)buffer, bufLen, &written);//check for error
 194                 if (ret != DRM_RESULT_SUCCESS) {
 195                         free(buffer);
 196                         MsgCloseFile(fp);
 197                         MSG_DEBUG("drm_svc_write_convert() return = failed (%d)", ret);
 198                         strncpy(outputFile, inputFile, MSG_MAX_DRM_FILE_PATH);
 199                         return false;
 200                 }
 201
 202                 ret = drm_svc_close_convert(hConvert);//check for error
 203                 if (ret != DRM_RESULT_SUCCESS) {
 204                         free(buffer);
 205                         MsgCloseFile(fp);
 206                         MSG_DEBUG("drm_svc_close_convert() return = failed (%d)", ret);
 207                         strncpy(outputFile, inputFile, MSG_MAX_DRM_FILE_PATH);
 208                         return false;
 209                 }
 210
 211                 MsgCloseFile(fp);
 212                 free(buffer);
 213         } else {
 214                 MSG_DEBUG("Current File extension is not .dm");
 215
 216                 MSG_DEBUG("inputFile = (%s)", inputFile);
 217                 strncpy(outputFile, inputFile, MSG_MAX_DRM_FILE_PATH);
 218
 219                 return false;
 220         }
 221
 222         return true;
 223 }
 224
 225 bool MsgDrmIsConvertedFL(char *szFilePath)
 226 {
 227         int ret = 0;
 228
 229         if (szFilePath == NULL) {
 230                 MSG_DEBUG("szFilePath is NULL.");
 231                 return false;
 232         }
 233
 234         MSG_DEBUG("szFilePath = [%s]", szFilePath);
 235
 236         ret = drm_svc_is_converted_fl(szFilePath);
 237
 238         if (ret != DRM_RESULT_SUCCESS) {
 239                 MSG_DEBUG("Drm2IsConvertedEmbeddedFile returns false ret = %d", ret);
 240                 return false;
 241         }
 242
 243         return true;
 244 }
 245
 246 int MsgDrmGetStreamSize(MSG_DRMHANDLE pHandle)
 247 { // Get DRM buffer size
 248         MSG_DEBUG("start");
 249         MSG_OPENEDDRM_INFO_T *pOpenDRMInfo = (MSG_OPENEDDRM_INFO_T *)pHandle;
 250         if (pOpenDRMInfo == NULL) {
 251                 MSG_DEBUG("end : Fail");
 252                 return 0;
 253         }
 254
 255         drm_file_attribute_t tDRMAttribute = {0,};
 256         DRM_RESULT eDRMResult = drm_svc_get_fileattribute(pOpenDRMInfo->szOpenedDRMFileName, &tDRMAttribute); // Get attribute of DRM File
 257         MSG_DEBUG("drm_svc_get_fileattribute : %d", eDRMResult);
 258         if (DRM_RESULT_SUCCESS == eDRMResult) {
 259                 return tDRMAttribute.size;
 260         }
 261         MSG_DEBUG("end : Fail");
 262         return 0;
 263 }
 264
 265 bool  MsgDrmGetStream(MSG_DRMHANDLE pHandle, int nStreamSize, unsigned char *pStream)
 266 { // Get DRM buffer
 267         MSG_DEBUG("start  %d", nStreamSize);
 268         MSG_OPENEDDRM_INFO_T *pOpenDRMInfo = (MSG_OPENEDDRM_INFO_T *)pHandle;
 269         if (pOpenDRMInfo == NULL) {
 270                 MSG_DEBUG("end : Fail");
 271                 return false;
 272         }
 273
 274         DRM_RESULT eDRMResult = DRM_RESULT_UNKNOWN_ERROR;
 275         DRM_FILE_HANDLE hFileHandle = NULL;
 276         eDRMResult = drm_svc_open_file(pOpenDRMInfo->szOpenedDRMFileName, DRM_PERMISSION_ANY, &hFileHandle); // Opens a DRM file
 277         MSG_DEBUG("drm_svc_open_file(%s) : %d", pOpenDRMInfo->szOpenedDRMFileName, eDRMResult);
 278
 279         unsigned int nRealReadSize = 0;
 280         if (hFileHandle) {
 281                 eDRMResult = drm_svc_read_file(hFileHandle, pStream, nStreamSize, &nRealReadSize); // Read the Decrypted Data from File Handle
 282         drm_svc_close_file(hFileHandle); // Close a DRM File which was opened before
 283                 if (DRM_RESULT_SUCCESS == eDRMResult) {
 284                         MSG_DEBUG("end : Success");
 285                         return true;
 286                 }
 287         }
 288         MSG_DEBUG("\n end : Fail \n=========================================\n");
 289         return false;
 290 }
 291
 292 bool MsgDrmOpen(MSG_DRM_OPENMODE eMode, const char *pBuffer, int nSize, MSG_DRMHANDLE *pHandle)
 293 {
 294         MSG_DEBUG("start (%d, %s, %d)", eMode, pBuffer, nSize);
 295         if (eMode == MSG_MODE_STREAM) {
 296                 MSG_DEBUG("end : Fail(eMode == MSG_MODE_STREAM)");
 297                 return false;
 298         }
 299
 300         char szFullFilePath[MSG_MAX_DRM_FILE_PATH] = {0,};
 301         char szFinalFullFilePath[MSG_MAX_DRM_FILE_PATH] = {0,};
 302         memset(szFullFilePath, 0x00, sizeof(char) * MSG_MAX_DRM_FILE_PATH);
 303         if (pBuffer)
 304                 strncpy(szFullFilePath, pBuffer, strlen(pBuffer));
 305
 306         MsgDrmConvertDmtoDcfType(szFullFilePath, szFinalFullFilePath);
 307
 308         if (!drm_svc_is_drm_file(szFinalFullFilePath)) {        // Check whether DRM file or not
 309                 MSG_DEBUG("return eDRM_NOT_DRM_FILE");
 310                 *pHandle = NULL;
 311                 return false;
 312         }
 313
 314         MSG_OPENEDDRM_INFO_T *pOpenDRMInfo = (MSG_OPENEDDRM_INFO_T *)malloc(sizeof(MSG_OPENEDDRM_INFO_T));
 315         if (pOpenDRMInfo) {
 316                 memset(pOpenDRMInfo, 0x0, sizeof(MSG_OPENEDDRM_INFO_T));
 317                 pOpenDRMInfo->szOpenedDRMFileName = (char *)malloc(sizeof(char) * (strlen(szFinalFullFilePath) + 1));
 318                 if (pOpenDRMInfo->szOpenedDRMFileName) {
 319                         memset(pOpenDRMInfo->szOpenedDRMFileName, 0x0, sizeof(char) * (strlen(szFinalFullFilePath) + 1));
 320                         strncpy(pOpenDRMInfo->szOpenedDRMFileName, szFinalFullFilePath, strlen(szFinalFullFilePath));
 321                         pOpenDRMInfo->eDRMType = MSG_DRM_NONE;
 322                         *pHandle = (MSG_DRMHANDLE)pOpenDRMInfo;
 323                         MSG_DEBUG("end : Success");
 324
 325                         return true;
 326                 }
 327                 free(pOpenDRMInfo);
 328         }
 329         MSG_DEBUG("end : Fail");
 330         return false;
 331 }
 332
 333 bool  MsgDrmClose(MSG_DRMHANDLE pHandle)
 334 { // Close DRM
 335         MSG_DEBUG("start");
 336         MSG_OPENEDDRM_INFO_T *pOpenDRMInfo = (MSG_OPENEDDRM_INFO_T *)pHandle;
 337         if (pOpenDRMInfo == NULL) {
 338                 MSG_DEBUG("end : Fail");
 339                 return false;
 340         }
 341         //free allocated memory from MsgDrmOpen
 342         if (pOpenDRMInfo->szOpenedDRMFileName) {
 343                 free(pOpenDRMInfo->szOpenedDRMFileName);
 344                 pOpenDRMInfo->szOpenedDRMFileName = NULL;
 345         }
 346
 347         free(pOpenDRMInfo);
 348
 349         MSG_DEBUG("end : Success");
 350         return true;
 351 }
 352
 353 bool MsgDrmGetMimeType(MSG_DRMHANDLE pHandle,  char *szMimeType, int nMimeTypeLen)
 354 {
 355         MSG_DEBUG("start");
 356         MSG_OPENEDDRM_INFO_T *pOpenDRMInfo = (MSG_OPENEDDRM_INFO_T *)pHandle;
 357         if (pOpenDRMInfo == NULL) {
 358                 MSG_DEBUG("end : Fail");
 359                 return false;
 360         }
 361
 362         drm_content_info_t tdcfContentinfo;
 363         memset(&tdcfContentinfo, 0x00, sizeof(drm_content_info_t));
 364         DRM_RESULT eDRMResult = drm_svc_get_content_info(pOpenDRMInfo->szOpenedDRMFileName, &tdcfContentinfo); // Get attribute of DRM File
 365         MSG_DEBUG("drm_svc_get_content_info : %d", eDRMResult);
 366         if (DRM_RESULT_SUCCESS == eDRMResult) {
 367                 MSG_DEBUG("end Success (%s)", tdcfContentinfo.contentType);
 368                 snprintf(szMimeType, nMimeTypeLen, "%s", tdcfContentinfo.contentType);
 369                 return true;
 370         }
 371         MSG_DEBUG("end : Fail");
 372         return false;
 373 }
 374
 375 bool MsgDrmGetDrmType(const char *szFileName, MSG_DRM_TYPE *eDRMType)
 376 {
 377         if (szFileName == NULL || eDRMType == NULL) {
 378                 MSG_DEBUG("Param is NULL");
 379                 return false;
 380         }
 381
 382         if (drm_svc_get_drm_type(szFileName) == DRM_FILE_TYPE_OMA) {
 383                 drm_dcf_info_t drmInfo;
 384                 DRM_RESULT eDRMResult = drm_svc_get_dcf_file_info(szFileName, &drmInfo); // Get information of DRM contents
 385                 if (DRM_RESULT_SUCCESS != eDRMResult) {
 386                         MSG_DEBUG("drm_svc_get_dcf_file_info is Fail eDRMResult = %d", eDRMResult);
 387                         return false;
 388                 }
 389
 390                 // Convert DRM_METHOD into MSG_DRM_TYPE
 391                 switch (drmInfo.method) {
 392                 case DRM_METHOD_FL:
 393                         *eDRMType = MSG_DRM_FORWARD_LOCK;
 394                         break;
 395                 case DRM_METHOD_CD:
 396                         *eDRMType = MSG_DRM_COMBINED_DELIVERY;
 397                         break;
 398                 case DRM_METHOD_SSD:
 399                         *eDRMType = MSG_DRM_SEPARATE_DELIVERY;
 400                         break;
 401                 case DRM_METHOD_SD:
 402                         *eDRMType = MSG_DRM_SEPARATE_DELIVERY;
 403                         break;
 404                 default:
 405                         *eDRMType = MSG_DRM_NONE;
 406                         break;
 407                 }
 408                 MSG_DEBUG("eDRMType : %d", *eDRMType);
 409         } else {
 410                 MSG_DEBUG("This is not a DRM_FILE_TYPE_OMA type");
 411                 return false;
 412         }
 413
 414         return true;
 415 }
 416
 417 bool MsgDrmConsumeRights(MSG_DRMHANDLE pHandle, MSG_DRM_RIGHT_TYPE eRightType, long nMiliSecs)
 418 {
 419         MSG_DEBUG("start %d, %ld", eRightType, nMiliSecs);
 420         MSG_DEBUG("end : Success");
 421         return true;
 422 }
 423
 424 bool MsgDrmIsAvailable(MSG_DRMHANDLE pHandle)
 425 {
 426         MSG_DEBUG("start");
 427         MSG_OPENEDDRM_INFO_T *pOpenDRMInfo = (MSG_OPENEDDRM_INFO_T *)pHandle;
 428         if (pOpenDRMInfo == NULL) {
 429                 MSG_DEBUG("end : Fail");
 430                 return false;
 431         }
 432
 433         if (pOpenDRMInfo->eDRMType == MSG_DRM_FORWARD_LOCK) {   //fl Àº ro ¾øÀÌµµ »ç¿ë°¡´É
 434                 MSG_DEBUG("end : Success");
 435                 return true;
 436         }
 437
 438         DRM_PERMISSION_TYPE ePerType = DRM_PERMISSION_ANY;
 439         drm_best_rights_t tBestRight; //ro ÀÖ´ÂÁö ¿©ºÎ¸¸ ¾Ë¸é µÇ¹Ç·Î drm_svc_get_best_ro ·Î Ã¼Å©ÇÏµµ·Ï ¼öÁ¤
 440         memset(&tBestRight, 0x00, sizeof(drm_best_rights_t));
 441         bool eReturn = false;
 442         DRM_RESULT eDRMResult = drm_svc_get_best_ro(pOpenDRMInfo->szOpenedDRMFileName, ePerType, &tBestRight); // Check the valided Rights or not by DCF file
 443         MSG_DEBUG("drm_svc_get_best_ro : %d", eDRMResult);
 444         if (DRM_RESULT_SUCCESS == eDRMResult && tBestRight.rightStatus == DRM_RIGHT_VALID) {
 445                 eReturn = true;
 446                 MSG_DEBUG("end : Success");
 447         } else {
 448                 MSG_DEBUG("end : Fail");
 449         }
 450         return eReturn;
 451 }
 452
 453 bool MsgDrmOnStart(MSG_DRMHANDLE pHandle, MSG_DRM_RIGHT_TYPE eRightType)
 454 { // Start consume
 455         MSG_DEBUG("start %d", eRightType);
 456         MSG_OPENEDDRM_INFO_T *pOpenDRMInfo = (MSG_OPENEDDRM_INFO_T *)pHandle;
 457         if (pOpenDRMInfo == NULL) {
 458                 MSG_DEBUG("end : Fail");
 459                 return false;
 460         }
 461
 462         if (pOpenDRMInfo->eDRMType == MSG_DRM_FORWARD_LOCK) {
 463                 MSG_DEBUG("end : Success");
 464                 return true;
 465         }
 466
 467         DRM_PERMISSION_TYPE eDRMUsage = DRM_PERMISSION_ANY;
 468         DRM_RIGHTS_CONSUME_HANDLE hRightsConsume = 0;
 469         switch (eRightType) {
 470         case MMS_DRM_RIGHT_PLAY:
 471                 eDRMUsage = DRM_PERMISSION_PLAY;
 472                 break;
 473         case MSG_DRM_RIGHT_DISPLAY:
 474                 eDRMUsage = DRM_PERMISSION_DISPLAY;
 475                 break;
 476         case MSG_DRM_RIGHT_EXECUTE:
 477                 eDRMUsage = DRM_PERMISSION_EXECUTE;
 478                 break;
 479         case MSG_DRM_RIGHT_PRINT:
 480                 eDRMUsage = DRM_PERMISSION_PRINT;
 481                 break;
 482         case MSG_DRM_RIGHT_EXPORT:
 483                 eDRMUsage = DRM_PERMISSION_EXPORT_MOVE; // DRM_PERMISSION_EXPORT_COPY µµ »ç¿ëÇØ¾ßÇÔ
 484                 break;
 485         }
 486         DRM_RESULT eDRMResult = drm_svc_open_consumption(pOpenDRMInfo->szOpenedDRMFileName, eDRMUsage, &hRightsConsume); // Open for consumption
 487         MSG_DEBUG("drm_svc_open_consumption : %d", eDRMResult);
 488         if (DRM_RESULT_SUCCESS != eDRMResult) {
 489                 MSG_DEBUG("end : Fail");
 490                 return false;
 491         }
 492         pOpenDRMInfo->hRightsConsume = hRightsConsume;
 493         eDRMResult = drm_svc_start_consumption(pOpenDRMInfo->hRightsConsume); // Start the consumption
 494         MSG_DEBUG("drm_svc_start_consumption : %d", eDRMResult);
 495         if (DRM_RESULT_SUCCESS == eDRMResult) {
 496                 MSG_DEBUG("end : Success");
 497                 return true;
 498         }
 499         MSG_DEBUG("end : Fail");
 500         return false;
 501 }
 502
 503 bool MsgDrmOnPause(MSG_DRMHANDLE pHandle, MSG_DRM_RIGHT_TYPE eRightType)
 504 {
 505         MSG_DEBUG("start %d", eRightType);
 506         MSG_OPENEDDRM_INFO_T *pOpenDRMInfo = (MSG_OPENEDDRM_INFO_T *)pHandle;
 507         if (pOpenDRMInfo == NULL) {
 508                 MSG_DEBUG("end : Fail");
 509                 return false;
 510         }
 511
 512         if (pOpenDRMInfo->eDRMType == MSG_DRM_FORWARD_LOCK) {
 513                 MSG_DEBUG("end : Success");
 514                 return true;
 515         }
 516
 517         DRM_RESULT eDRMResult = drm_svc_pause_consumption(pOpenDRMInfo->hRightsConsume); // Pause the consumption
 518         MSG_DEBUG("drm_svc_pause_consumption : %d", eDRMResult);
 519         if (DRM_RESULT_SUCCESS == eDRMResult) {
 520                 MSG_DEBUG("end : Success");
 521                 return true;
 522         }
 523         MSG_DEBUG("end : Fail");
 524         return false;
 525 }
 526
 527 bool MsgDrmOnResume(MSG_DRMHANDLE pHandle, MSG_DRM_RIGHT_TYPE eRightType)
 528 {
 529         MSG_DEBUG("start %d", eRightType);
 530         MSG_DEBUG("end : Success");
 531         return true;
 532 }
 533
 534 bool MsgDrmOnStop(MSG_DRMHANDLE pHandle, MSG_DRM_RIGHT_TYPE eRightType)
 535 {
 536         MSG_DEBUG("start %d", eRightType);
 537         MSG_OPENEDDRM_INFO_T *pOpenDRMInfo = (MSG_OPENEDDRM_INFO_T *)pHandle;
 538         if (pOpenDRMInfo == NULL) {
 539                 MSG_DEBUG("end : Fail");
 540                 return false;
 541         }
 542
 543         if (pOpenDRMInfo->eDRMType == MSG_DRM_FORWARD_LOCK) {
 544                 MSG_DEBUG("end : Success");
 545                 return true;
 546         }
 547
 548         DRM_RESULT eDRMResult = drm_svc_stop_consumption(pOpenDRMInfo->hRightsConsume); // Stop the consumption
 549         MSG_DEBUG("drm_svc_stop_consumption : %d", eDRMResult);
 550         if (DRM_RESULT_SUCCESS != eDRMResult) {
 551                 MSG_DEBUG("end : Fail");
 552                 return false;
 553         }
 554
 555         eDRMResult = drm_svc_close_consumption(&(pOpenDRMInfo->hRightsConsume)); // Close the consumption
 556         MSG_DEBUG("drm_svc_close_consumption : %d", eDRMResult);
 557         if (DRM_RESULT_SUCCESS == eDRMResult) {
 558                 pOpenDRMInfo->hRightsConsume = 0;
 559                 MSG_DEBUG("end : Success");
 560                 return true;
 561         }
 562         MSG_DEBUG("end : Fail");
 563         return false;
 564 }
 565
 566 bool MsgDrmGetMimeTypeEx(const char *szFileName, char *szMimeType, int nMimeTypeLen)
 567 {
 568         if (!szFileName || !szMimeType || !nMimeTypeLen) {
 569                 MSG_DEBUG("param is NULL");
 570                 return false;
 571         }
 572
 573         char strTemp[MSG_MAX_DRM_FILE_PATH + 1] = {0,};
 574
 575         strncpy(strTemp, szFileName, strlen(szFileName));
 576
 577         drm_content_info_t tdcfContentinfo;
 578         memset(&tdcfContentinfo, 0x00, sizeof(drm_content_info_t));
 579         DRM_RESULT eDRMResult = drm_svc_get_content_info(strTemp, &tdcfContentinfo); // Get attribute of DRM File
 580         if (DRM_RESULT_SUCCESS == eDRMResult) {
 581                 MSG_DEBUG("contentType = %s", tdcfContentinfo.contentType);
 582                 snprintf(szMimeType, nMimeTypeLen, "%s", tdcfContentinfo.contentType);
 583
 584                 return true;
 585         } else {
 586                 MSG_DEBUG("drm_svc_get_content_info is failed %d", eDRMResult);
 587         }
 588
 589         return false;
 590 }
 591
 592 bool MsgDrmGetContentID(const char *szFileName, char *szContentID, int nContentIDLen)
 593 {
 594         if (!szFileName || !szContentID || !nContentIDLen) {
 595                 MSG_DEBUG("param is NULL");
 596                 return false;
 597         }
 598
 599         char strTemp[MSG_MAX_DRM_FILE_PATH + 1] = {0,};
 600
 601         strncpy(strTemp, szFileName, sizeof(strTemp));
 602
 603         drm_content_info_t  tdcfContentinfo;
 604         memset(&tdcfContentinfo, 0x00, sizeof(drm_content_info_t));
 605         DRM_RESULT eDRMResult = drm_svc_get_content_info(strTemp, &tdcfContentinfo);
 606         if (DRM_RESULT_SUCCESS == eDRMResult) {
 607                 MSG_DEBUG("contentID = %s", tdcfContentinfo.contentID);
 608         snprintf(szContentID, nContentIDLen, "%s", tdcfContentinfo.contentID);
 609
 610                 return true;
 611         } else {
 612                 MSG_DEBUG("drm_svc_get_content_info is failed %d", eDRMResult);
 613         }
 614
 615         return false;
 616 }
 617