test/drm_testapps.cpp

   1 /*
   2  * Copyright (c) 2000-2015 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <vector>
  18 #include <fstream>
  19 #include <iostream>
  20
  21 #include "drm-tizen-apps.h"
  22 #include "drm-tizen-error.h"
  23 #include "TADC_Core.h"
  24 #include "TADC_IF.h"
  25 #include "DrmFileMgr.h"
  26
  27 #include "DTapps2Rights.h"
  28 #include "drm_testutil.h"
  29 #include "drm_testcore.h"
  30
  31 #if 1
  32 static int first_key = 0;
  33 static int second_key = 0;
  34 static int third_key = 0;
  35
  36 bool _write_logfile(const char *filename, char *buf, unsigned int len)
  37 {
  38         FILE *fd = NULL;
  39
  40         if ((fd = fopen(filename, "w+b")) == NULL) {
  41                 return false;
  42         }
  43
  44         fwrite(buf, 1, len, fd);
  45         fclose(fd);
  46
  47         return true;
  48 }
  49
  50 bool _read_logfile(const char *filename, char *buf, unsigned int *pLen)
  51 {
  52         FILE *fd = NULL;
  53         int  nReadLen = 0;
  54
  55         if ((fd = fopen(filename, "r+b")) == NULL) {
  56                 return false;
  57         }
  58
  59         nReadLen = fread(buf, 1, *pLen, fd);
  60         *pLen = nReadLen;
  61
  62         fclose(fd);
  63
  64         return true;
  65 }
  66
  67 bool tc01_VerifyRoSignature_Positive_01(void)
  68 {
  69         printf("tc01_VerifyRoSignature_Positive_01() -------- Started! \n");
  70
  71         const char *pRo = TEST_DATA_DIR "/RO/38EIfBurLJ-1.0.2.ro";
  72
  73         auto buf = _read_ro_file(pRo);
  74
  75         int nRet = TADC_VerifyROSignature(buf.data());
  76
  77         if (nRet != 0) {
  78                 printf("VerifyROSignature Failed! : %s, %d\n", pRo, nRet);
  79                 return false;
  80         }
  81
  82         printf("tc01_VerifyRoSignature_Positive_01() finished! -------- success \n");
  83
  84         return true;
  85 }
  86
  87 bool tc01_VerifyRoSignature_Positive_02(void)
  88 {
  89         printf("tc01_VerifyRoSignature_Positive_02() -------- Started! \n");
  90         const char *pRo = TEST_DATA_DIR "/RO/8SPXfqc6iL-1.0.0.ro";
  91
  92         auto buf = _read_ro_file(pRo);
  93
  94         int nRet = TADC_VerifyROSignature(buf.data());
  95
  96         if (nRet != 0) {
  97                 printf("VerifyROSignature Failed! : %s, %d\n", pRo, nRet);
  98                 return false;
  99         }
 100
 101         printf("tc01_VerifyRoSignature_Positive_02() finished! -------- success \n");
 102         return true;
 103 }
 104
 105 bool tc01_VerifyRoSignature_Positive_03(void)
 106 {
 107         printf("tc01_VerifyRoSignature_Positive_03() -------- Started! \n");
 108
 109         const char *pRo = TEST_DATA_DIR "/RO/FightGuiIF-1.0.0.ro";
 110
 111         auto buf = _read_ro_file(pRo);
 112
 113         int nRet = TADC_VerifyROSignature(buf.data());
 114
 115         if (nRet != 0) {
 116                 printf("VerifyROSignature Failed! : %s, %d\n", pRo, nRet);
 117                 return false;
 118         }
 119
 120         printf("tc01_VerifyRoSignature_Positive_03() finished! -------- success \n");
 121         return true;
 122 }
 123
 124 bool tc02_VerifyRoSignature_Negative_Cert_01(void)
 125 {
 126         printf("tc02_VerifyRoSignature_Negative_Cert_01() -------- Started! \n");
 127
 128         const char *pRo  = TEST_DATA_DIR "/RO/38EIfBurLJ-1.0.2.cert_only_selfsigned.ro";
 129
 130         auto buf = _read_ro_file(pRo);
 131
 132         int nRet = TADC_VerifyROSignature(buf.data());
 133
 134         if (nRet >= 0) {
 135                 printf("VerifyROSignature have to be failed. But success! : %s, %d\n", pRo,
 136                            nRet);
 137                 return false;
 138         }
 139
 140         printf("tc02_VerifyRoSignature_Negative_Cert_01 finished! -------- success \n");
 141         return true;
 142 }
 143
 144 bool tc02_VerifyRoSignature_Negative_Cert_02(void)
 145 {
 146         printf("tc02_VerifyRoSignature_Negative_Cert_02() -------- Started! \n");
 147
 148         const char *pRo = TEST_DATA_DIR "/RO/38EIfBurLJ-1.0.2.cert_chain_invalid.ro";
 149
 150         auto buf = _read_ro_file(pRo);
 151
 152         int nRet = TADC_VerifyROSignature(buf.data());
 153
 154         if (nRet >= 0) {
 155                 printf("VerifyROSignature have to be failed. But success! : %s, %d\n", pRo,
 156                            nRet);
 157                 return false;
 158         }
 159
 160         printf("tc02_VerifyRoSignature_Negative_Cert_02 finished! -------- success \n");
 161         return true;
 162 }
 163
 164 bool tc02_VerifyRoSignature_Negative_Cert_03(void)
 165 {
 166         printf("tc02_VerifyRoSignature_Negative_Cert_03() -------- Started! \n");
 167
 168         const char *pRo  = TEST_DATA_DIR "/RO/38EIfBurLJ-1.0.2.cert_invalid.ro";
 169
 170         auto buf = _read_ro_file(pRo);
 171
 172         int nRet = TADC_VerifyROSignature(buf.data());
 173
 174         if (nRet >= 0) {
 175                 printf("VerifyROSignature have to be failed. But success! : %s, %d\n", pRo,
 176                            nRet);
 177                 return false;
 178         }
 179
 180         printf("tc02_VerifyRoSignature_Negative_Cert_03 finished! -------- success \n");
 181         return true;
 182 }
 183
 184 bool tc03_VerifyRoSignature_Negative_Signature_01(void)
 185 {
 186         printf("tc03_VerifyRoSignature_Negative_Signature_01() -------- Started! \n");
 187
 188         const char *pRo   = TEST_DATA_DIR "/RO/FightGuiIF-1.0.0.signature_invalid.ro";
 189
 190         auto buf = _read_ro_file(pRo);
 191
 192         int nRet = TADC_VerifyROSignature(buf.data());
 193
 194         if (nRet >= 0) {
 195                 printf("VerifyROSignature have to be failed. But success! : %s, %d\n", pRo,
 196                            nRet);
 197                 return false;
 198         }
 199
 200         printf("tc03_VerifyRoSignature_Negative_Signature_01() finished! -------- success \n");
 201
 202         return true;
 203 }
 204
 205 bool tc03_VerifyRoSignature_Negative_Signature_02(void)
 206 {
 207         printf("tc03_VerifyRoSignature_Negative_Signature_02() -------- Started! \n");
 208
 209         const char *pRo = TEST_DATA_DIR "/RO/38EIfBurLJ-1.0.2.signature_invalid.ro";
 210
 211         auto buf = _read_ro_file(pRo);
 212
 213         int nRet = TADC_VerifyROSignature(buf.data());
 214
 215         if (nRet >= 0) {
 216                 printf("VerifyROSignature have to be failed. But success! : %s, %d\n", pRo,
 217                            nRet);
 218                 return false;
 219         }
 220
 221         printf("tc03_VerifyRoSignature_Negative_Signature_01() finished! -------- success \n");
 222
 223         return true;
 224 }
 225
 226 bool tc03_VerifyRoSignature_Negative_Signature_03(void)
 227 {
 228         printf("tc03_VerifyRoSignature_Negative_Signature_03() -------- Started! \n");
 229
 230         const char *pRo  = TEST_DATA_DIR "/RO/8SPXfqc6iL-1.0.0.signature_invalid.ro";
 231
 232         auto buf = _read_ro_file(pRo);
 233
 234         int nRet = TADC_VerifyROSignature(buf.data());
 235
 236         if (nRet >= 0) {
 237                 printf("VerifyROSignature have to be failed. But success! : %s, %d\n", pRo,
 238                            nRet);
 239                 return false;
 240         }
 241
 242         printf("tc03_VerifyRoSignature_Negative_Signature_03() finished! -------- success \n");
 243
 244         return true;
 245 }
 246
 247 bool tc04_isDrmFile_Positive_01(void)
 248 {
 249         const char *pDCF = TEST_DATA_DIR "/DCF/38EIfBurLJ.tpk";
 250
 251         printf("tc04_isDrmFile_Positive_01() -------- Started!\n");
 252
 253         int nRet = drm_tizen_is_drm_file(pDCF, strlen(pDCF));
 254
 255         if (nRet != TADC_SUCCESS) {
 256                 printf("drm_tizen_is_drm_file failed. Path = %s, Ret = %d\n", pDCF,  nRet);
 257                 printf("%s file is not TADC file!\n", pDCF);
 258                 return false;
 259         }
 260
 261         printf("tc04_isDrmFile_Positive_01() finished! -------- success \n");
 262
 263         return true;
 264 }
 265
 266 bool tc04_isDrmFile_Positive_02(void)
 267 {
 268         const char *pDCF = TEST_DATA_DIR "/DCF/8SPXfqc6iL.tpk";
 269
 270         printf("tc04_isDrmFile_Positive_02() -------- Started!\n");
 271
 272         int nRet = drm_tizen_is_drm_file(pDCF, strlen(pDCF));
 273
 274         if (nRet != TADC_SUCCESS) {
 275                 printf("drm_tizen_is_drm_file failed. Path = %s, Ret = %d\n", pDCF,  nRet);
 276                 printf("%s file is not TADC file!\n", pDCF);
 277                 return false;
 278         }
 279
 280         printf("tc04_isDrmFile_Positive_02() finished! -------- success \n");
 281
 282         return true;
 283 }
 284
 285 bool tc04_isDrmFile_Positive_03(void)
 286 {
 287         const char *pDCF = TEST_DATA_DIR "/DCF/FightGuiIF.tpk";
 288
 289         printf("tc04_isDrmFile_Positive_03() -------- Started!\n");
 290
 291         int nRet = drm_tizen_is_drm_file(pDCF, strlen(pDCF));
 292
 293         if (nRet != TADC_SUCCESS) {
 294                 printf("drm_tizen_is_drm_file failed. Path = %s, Ret = %d\n", pDCF,  nRet);
 295                 printf("%s file is not TADC file!\n", pDCF);
 296                 return false;
 297         }
 298
 299         printf("tc04_isDrmFile_Positive_03() finished! -------- success \n");
 300
 301         return true;
 302 }
 303
 304 bool tc05_isDrmFile_Negative_01(void)
 305 {
 306         const char *pApp = TEST_DATA_DIR "/DecryptedApp/38EIfBurLJ_dec.tpk";
 307
 308         printf("tc05_isDrmFile_Negative_01() -------- Started! \n");
 309
 310         int nRet = drm_tizen_is_drm_file(pApp, strlen(pApp));
 311
 312         if (nRet == TADC_SUCCESS) {
 313                 printf("drm_tizen_is_drm_file have to be failed. But Success!  Path = %s, Ret = %d\n",
 314                            pApp,  nRet);
 315                 return false;
 316         }
 317
 318         printf("tc05_isDrmFile_Negative_01 finished! -------- success \n");
 319
 320         return true;
 321 }
 322
 323 bool tc05_isDrmFile_Negative_02(void)
 324 {
 325         const char *pApp = TEST_DATA_DIR "/DecryptedApp/8SPXfqc6iL_dec.tpk";
 326
 327         printf("tc05_isDrmFile_Negative_02() -------- Started! \n");
 328
 329         int nRet = drm_tizen_is_drm_file(pApp, strlen(pApp));
 330
 331         if (nRet == TADC_SUCCESS) {
 332                 printf("drm_tizen_is_drm_file have to be failed. But Success!  Path = %s, Ret = %d\n",
 333                            pApp,  nRet);
 334                 return false;
 335         }
 336
 337         printf("tc05_isDrmFile_Negative_02 finished! -------- success \n");
 338
 339         return true;
 340 }
 341
 342 bool tc05_isDrmFile_Negative_03(void)
 343 {
 344         const char *pApp = TEST_DATA_DIR "/DecryptedApp/FightGuiIF_dec.tpk";
 345
 346         printf("tc05_isDrmFile_Negative_03() -------- Started! \n");
 347
 348         int nRet = drm_tizen_is_drm_file(pApp, strlen(pApp));
 349
 350         if (nRet == TADC_SUCCESS) {
 351                 printf("drm_tizen_is_drm_file have to be failed. But Success!  Path = %s, Ret = %d\n",
 352                            pApp,  nRet);
 353                 return false;
 354         }
 355
 356         printf("tc05_isDrmFile_Negative_03 finished! -------- success \n");
 357
 358         return true;
 359 }
 360
 361 bool
 362 tc06_DrmFileHandlerPositive_01(void)
 363 {
 364         const char *pDCF = TEST_DATA_DIR "/DCF/38EIfBurLJ.tpk";
 365         DrmFileHandler *pDcfHandler = NULL;
 366         unsigned char *pBufCEK = NULL;
 367         unsigned char pCEK[CEK_SIZE + 1] = {0xB1, 0x03, 0x4F, 0x30, 0xC8, 0x52, 0x45, 0x7E, 0x9D, 0xA2, 0x52, 0x25, 0x2E, 0xA9, 0x9B, 0x2B, 0x25, 0x36, 0xF1, 0x8D, 0x04, 0xD1, 0x4C, 0xE3, 0x96, 0x81, 0xD9, 0x98, 0xBB, 0xD7, 0x7E, 0xCA, 0x00};
 368         unsigned char pCID[32] = "38EIfBurLJ-1.0.2";
 369
 370         long encryptionLevel = 17;
 371         long long encryptionRange = 10;
 372         long long plainTextSize = 1630724;
 373         long long originalEndOffset = 1631570;
 374         int nRet = 0;
 375
 376         printf("tc06_DrmFileHandlerPositive_01() -------- Started! \n");
 377
 378         pBufCEK = (unsigned char *)malloc(CEK_SIZE + 1);
 379         memset(pBufCEK, 0x00, CEK_SIZE + 1);
 380
 381         pDcfHandler = new DrmFileHandler();
 382
 383         if (pDcfHandler == NULL) {
 384                 goto CATCH;
 385         }
 386
 387         nRet = pDcfHandler->Construct(pDCF);
 388
 389         if (nRet != 1) {
 390                 printf("tc06_DrmFileHandlerPositive_01 - Construct() failed : %s, %x\n", pDCF,
 391                            nRet);
 392                 goto CATCH;
 393         }
 394
 395         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0) {
 396                 printf("tc06_DrmFileHandlerPositive_01 - CEK Comparison failed : %s\n", pDCF);
 397                 goto CATCH;
 398         }
 399
 400         if (memcmp(pDCF, pDcfHandler->m_pFilePath,
 401                            strlen((char *)pDcfHandler->m_pFilePath)) != 0) {
 402                 printf("tc06_DrmFileHandlerPositive_01 - FilePath Comparison failed : %s\n",
 403                            pDcfHandler->m_pFilePath);
 404                 goto CATCH;
 405         }
 406
 407         if (memcmp(pCID, pDcfHandler->m_pCID,
 408                            strlen((char *)pDcfHandler->m_pCID)) != 0) {
 409                 printf("tc06_DrmFileHandlerPositive_01 - CID Comparison failed : %s\n",
 410                            pDcfHandler->m_pCID);
 411                 goto CATCH;
 412         }
 413
 414         if (pDcfHandler->m_encryptionLevel != encryptionLevel) {
 415                 printf("tc06_DrmFileHandlerPositive_01 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n",
 416                            encryptionLevel, pDcfHandler->m_encryptionLevel);
 417                 goto CATCH;
 418         }
 419
 420         if (pDcfHandler->m_encryptionRange != encryptionRange) {
 421                 printf("tc06_DrmFileHandlerPositive_01 - encryptionRange Comparison failed : origin = %lld, result = %lld\n",
 422                            encryptionRange, pDcfHandler->m_encryptionRange);
 423                 goto CATCH;
 424         }
 425
 426         if (pDcfHandler->m_plaintextSize != plainTextSize) {
 427                 printf("tc06_DrmFileHandlerPositive_01 - plainTextSize Comparison failed : origin = %lld, result = %lld\n",
 428                            plainTextSize, pDcfHandler->m_plaintextSize);
 429                 goto CATCH;
 430         }
 431
 432         if (pDcfHandler->m_OriginEndOffset != originalEndOffset) {
 433                 printf("tc06_DrmFileHandlerPositive_01 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n",
 434                            originalEndOffset, pDcfHandler->m_OriginEndOffset);
 435                 goto CATCH;
 436         }
 437
 438         if (pDcfHandler != NULL) {
 439                 delete pDcfHandler;
 440         }
 441
 442         if (pBufCEK != NULL) {
 443                 free(pBufCEK);
 444         }
 445
 446         printf("tc06_DrmFileHandlerPositive_01 finished! -------- success \n");
 447
 448         return true;
 449
 450 CATCH:
 451
 452         if (pDcfHandler != NULL) {
 453                 delete pDcfHandler;
 454         }
 455
 456         if (pBufCEK != NULL) {
 457                 free(pBufCEK);
 458         }
 459
 460         return false;
 461 }
 462
 463 bool
 464 tc06_DrmFileHandlerPositive_02(void)
 465 {
 466         const char *pDCF = TEST_DATA_DIR "/DCF/8SPXfqc6iL.tpk";
 467         unsigned char *pBufCEK = NULL;
 468         DrmFileHandler *pDcfHandler = NULL;
 469         unsigned char pCEK[CEK_SIZE + 1] = {0xBB, 0x87, 0x5D, 0xA8, 0x2C, 0xC4, 0x47, 0x81, 0x90, 0xBA, 0xD9, 0xB0, 0x0C, 0xD2, 0x94, 0xE9, 0x19, 0x0F, 0x24, 0x62, 0x5B, 0x0B, 0x49, 0x7A, 0xAE, 0x8E, 0x1D, 0x88, 0x7F, 0xF9, 0x96, 0xDB, 0x00};
 470         unsigned char pCID[32] = "8SPXfqc6iL-1.0.0";
 471
 472         long encryptionLevel = 17;
 473         long long encryptionRange = 10;
 474         long long plainTextSize = 705072;
 475         long long originalEndOffset = 705914;
 476         int nRet = 0;
 477
 478         printf("tc06_DrmFileHandlerPositive_02() -------- Started! \n");
 479
 480         pBufCEK = (unsigned char *)malloc(CEK_SIZE + 1);
 481         memset(pBufCEK, 0x00, CEK_SIZE + 1);
 482
 483         pDcfHandler = new DrmFileHandler();
 484
 485         if (pDcfHandler == NULL) {
 486                 goto CATCH;
 487         }
 488
 489         nRet = pDcfHandler->Construct(pDCF);
 490
 491         if (nRet != 1) {
 492                 printf("tc06_DrmFileHandlerPositive_02 - Construct() failed : %s, %x\n", pDCF,
 493                            nRet);
 494                 goto CATCH;
 495         }
 496
 497         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0) {
 498                 printf("tc06_DrmFileHandlerPositive_02 - CEK Comparison failed : %s\n", pDCF);
 499                 goto CATCH;
 500         }
 501
 502         if (memcmp(pDCF, pDcfHandler->m_pFilePath,
 503                            strlen((char *)pDcfHandler->m_pFilePath)) != 0) {
 504                 printf("tc06_DrmFileHandlerPositive_02 - FilePath Comparison failed : %s\n",
 505                            pDcfHandler->m_pFilePath);
 506                 goto CATCH;
 507         }
 508
 509         if (memcmp(pCID, pDcfHandler->m_pCID,
 510                            strlen((char *)pDcfHandler->m_pCID)) != 0) {
 511                 printf("tc06_DrmFileHandlerPositive_02 - CID Comparison failed : %s\n",
 512                            pDcfHandler->m_pCID);
 513                 goto CATCH;
 514         }
 515
 516         if (pDcfHandler->m_encryptionLevel != encryptionLevel) {
 517                 printf("tc06_DrmFileHandlerPositive_02 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n",
 518                            encryptionLevel, pDcfHandler->m_encryptionLevel);
 519                 goto CATCH;
 520         }
 521
 522         if (pDcfHandler->m_encryptionRange != encryptionRange) {
 523                 printf("tc06_DrmFileHandlerPositive_02 - encryptionRange Comparison failed : origin = %lld, result = %lld\n",
 524                            encryptionRange, pDcfHandler->m_encryptionRange);
 525                 goto CATCH;
 526         }
 527
 528         if (pDcfHandler->m_plaintextSize != plainTextSize) {
 529                 printf("tc06_DrmFileHandlerPositive_02 - plainTextSize Comparison failed : origin = %lld, result = %lld\n",
 530                            plainTextSize, pDcfHandler->m_plaintextSize);
 531                 goto CATCH;
 532         }
 533
 534         if (pDcfHandler->m_OriginEndOffset != originalEndOffset) {
 535                 printf("tc06_DrmFileHandlerPositive_02 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n",
 536                            originalEndOffset, pDcfHandler->m_OriginEndOffset);
 537                 goto CATCH;
 538         }
 539
 540         if (pDcfHandler != NULL) {
 541                 delete pDcfHandler;
 542         }
 543
 544         if (pBufCEK != NULL) {
 545                 free(pBufCEK);
 546         }
 547
 548         printf("tc06_DrmFileHandlerPositive_02 finished! -------- success \n");
 549
 550         return true;
 551
 552 CATCH:
 553
 554         if (pDcfHandler != NULL) {
 555                 delete pDcfHandler;
 556         }
 557
 558         if (pBufCEK != NULL) {
 559                 free(pBufCEK);
 560         }
 561
 562         return false;
 563 }
 564
 565 bool
 566 tc06_DrmFileHandlerPositive_03(void)
 567 {
 568         const char *pDCF = TEST_DATA_DIR "/DCF/FightGuiIF.tpk";
 569         unsigned char *pBufCEK = NULL;
 570         DrmFileHandler *pDcfHandler = NULL;
 571         unsigned char pCEK[CEK_SIZE + 1] = {0x34, 0x5A, 0x94, 0x28, 0xC3, 0xF4, 0x44, 0x3F, 0x86, 0x6D, 0xCF, 0xC5, 0x78, 0x1F, 0x23, 0xCE, 0xE9, 0x9B, 0xC4, 0x45, 0xA3, 0x30, 0x47, 0x1E, 0xB4, 0xE0, 0xAF, 0x96, 0x0F, 0xDE, 0xA9, 0xB4, 0x00};
 572         unsigned char pCID[32] = "FightGuiIF-1.0.0";
 573
 574         long encryptionLevel = 17;
 575         long long encryptionRange = 10;
 576         long long plainTextSize = 45193789;
 577         long long originalEndOffset = 45194636;
 578         int nRet = 0;
 579
 580         printf("tc06_DrmFileHandlerPositive_03() -------- Started! \n");
 581
 582         pBufCEK = (unsigned char *)malloc(CEK_SIZE + 1);
 583         memset(pBufCEK, 0x00, CEK_SIZE + 1);
 584
 585         pDcfHandler = new DrmFileHandler();
 586
 587         if (pDcfHandler == NULL) {
 588                 goto CATCH;
 589         }
 590
 591         nRet = pDcfHandler->Construct(pDCF);
 592
 593         if (nRet != 1) {
 594                 printf("tc06_DrmFileHandlerPositive_03 - Construct() failed : %s, %x\n", pDCF,
 595                            nRet);
 596                 goto CATCH;
 597         }
 598
 599         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0) {
 600                 printf("tc06_DrmFileHandlerPositive_03 - CEK Comparison failed : %s\n", pDCF);
 601                 goto CATCH;
 602         }
 603
 604         if (memcmp(pDCF, pDcfHandler->m_pFilePath,
 605                            strlen((char *)pDcfHandler->m_pFilePath)) != 0) {
 606                 printf("tc06_DrmFileHandlerPositive_03 - FilePath Comparison failed : %s\n",
 607                            pDcfHandler->m_pFilePath);
 608                 goto CATCH;
 609         }
 610
 611         if (memcmp(pCID, pDcfHandler->m_pCID,
 612                            strlen((char *)pDcfHandler->m_pCID)) != 0) {
 613                 printf("tc06_DrmFileHandlerPositive_03 - CID Comparison failed : %s\n",
 614                            pDcfHandler->m_pCID);
 615                 goto CATCH;
 616         }
 617
 618         if (pDcfHandler->m_encryptionLevel != encryptionLevel) {
 619                 printf("tc06_DrmFileHandlerPositive_03 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n",
 620                            encryptionLevel, pDcfHandler->m_encryptionLevel);
 621                 goto CATCH;
 622         }
 623
 624         if (pDcfHandler->m_encryptionRange != encryptionRange) {
 625                 printf("tc06_DrmFileHandlerPositive_03 - encryptionRange Comparison failed : origin = %lld, result = %lld\n",
 626                            encryptionRange, pDcfHandler->m_encryptionRange);
 627                 goto CATCH;
 628         }
 629
 630         if (pDcfHandler->m_plaintextSize != plainTextSize) {
 631                 printf("tc06_DrmFileHandlerPositive_03 - plainTextSize Comparison failed : origin = %lld, result = %lld\n",
 632                            plainTextSize, pDcfHandler->m_plaintextSize);
 633                 goto CATCH;
 634         }
 635
 636         if (pDcfHandler->m_OriginEndOffset != originalEndOffset) {
 637                 printf("tc06_DrmFileHandlerPositive_03 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n",
 638                            originalEndOffset, pDcfHandler->m_OriginEndOffset);
 639                 goto CATCH;
 640         }
 641
 642         if (pDcfHandler != NULL) {
 643                 delete pDcfHandler;
 644         }
 645
 646         if (pBufCEK != NULL) {
 647                 free(pBufCEK);
 648         }
 649
 650         printf("tc06_DrmFileHandlerPositive_03 finished! -------- success \n");
 651
 652         return true;
 653
 654 CATCH:
 655
 656         if (pDcfHandler != NULL) {
 657                 delete pDcfHandler;
 658         }
 659
 660         if (pBufCEK != NULL) {
 661                 free(pBufCEK);
 662         }
 663
 664         return false;
 665 }
 666
 667 bool tc07_DrmFileMgrPositive_01(void)
 668 {
 669         const char *pDCF = TEST_DATA_DIR "/DCF/38EIfBurLJ.tpk";
 670         int nRet = TADC_SUCCESS;
 671
 672         DrmFileMgr *pDrmFileMgr = NULL;
 673         DrmFileHandler *pDcfHandler = NULL;
 674
 675         unsigned char pCEK[CEK_SIZE + 1] = {0xB1, 0x03, 0x4F, 0x30, 0xC8, 0x52, 0x45, 0x7E, 0x9D, 0xA2, 0x52, 0x25, 0x2E, 0xA9, 0x9B, 0x2B, 0x25, 0x36, 0xF1, 0x8D, 0x04, 0xD1, 0x4C, 0xE3, 0x96, 0x81, 0xD9, 0x98, 0xBB, 0xD7, 0x7E, 0xCA, 0x00};
 676
 677         unsigned char pCID[32] = "38EIfBurLJ-1.0.2";
 678         long encryptionLevel = 17;
 679         long long encryptionRange = 10;
 680         long long plainTextSize = 1630724;
 681         long long originalEndOffset = 1631570;
 682
 683         printf("tc07_DrmFileMgrPositive_01() -------- Started! \n");
 684
 685         pDrmFileMgr = DrmFileMgr::GetInstance();
 686
 687         nRet = pDrmFileMgr->OpenFileHandler(pDCF, &first_key);
 688
 689         if (nRet != TADC_SUCCESS) {
 690                 printf("tc07_DrmFileMgrPositive_01 - OpenFileHandler() failed : key = %d, file = %s, %x\n",
 691                            first_key, pDCF, nRet);
 692                 goto CATCH;
 693         }
 694
 695         nRet = pDrmFileMgr->GetFileHandler(first_key, &pDcfHandler);
 696
 697         if (nRet != TADC_SUCCESS) {
 698                 printf("tc07_DrmFileMgrPositive_01 - GetFileHandler() failed : key = %d, file = %s, %x\n",
 699                            first_key, pDCF, nRet);
 700                 goto CATCH;
 701         }
 702
 703         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0) {
 704                 printf("tc07_DrmFileMgrPositive_01 - CEK Comparison failed : %s\n", pDCF);
 705                 goto CATCH;
 706         }
 707
 708         if (memcmp(pDCF, pDcfHandler->m_pFilePath,
 709                            strlen((char *)pDcfHandler->m_pFilePath)) != 0) {
 710                 printf("tc07_DrmFileMgrPositive_01 - FilePath Comparison failed : %s\n",
 711                            pDcfHandler->m_pFilePath);
 712                 goto CATCH;
 713         }
 714
 715         if (memcmp(pCID, pDcfHandler->m_pCID,
 716                            strlen((char *)pDcfHandler->m_pCID)) != 0) {
 717                 printf("tc07_DrmFileMgrPositive_01 - CID Comparison failed : %s\n",
 718                            pDcfHandler->m_pCID);
 719                 goto CATCH;
 720         }
 721
 722         if (pDcfHandler->m_encryptionLevel != encryptionLevel) {
 723                 printf("tc07_DrmFileMgrPositive_01 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n",
 724                            encryptionLevel, pDcfHandler->m_encryptionLevel);
 725                 goto CATCH;
 726         }
 727
 728         if (pDcfHandler->m_encryptionRange != encryptionRange) {
 729                 printf("tc07_DrmFileMgrPositive_01 - encryptionRange Comparison failed : origin = %lld, result = %lld\n",
 730                            encryptionRange, pDcfHandler->m_encryptionRange);
 731                 goto CATCH;
 732         }
 733
 734         if (pDcfHandler->m_plaintextSize != plainTextSize) {
 735                 printf("tc07_DrmFileMgrPositive_01 - plainTextSize Comparison failed : origin = %lld, result = %lld\n",
 736                            plainTextSize, pDcfHandler->m_plaintextSize);
 737                 goto CATCH;
 738         }
 739
 740         if (pDcfHandler->m_OriginEndOffset != originalEndOffset) {
 741                 printf("tc07_DrmFileMgrPositive_01 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n",
 742                            originalEndOffset, pDcfHandler->m_OriginEndOffset);
 743                 goto CATCH;
 744         }
 745
 746         printf("tc07_DrmFileMgrPositive_01 finished! -------- success \n");
 747
 748         return true;
 749
 750 CATCH:
 751
 752         return false;
 753 }
 754
 755 bool tc07_DrmFileMgrPositive_02(void)
 756 {
 757         const char *pDCF = TEST_DATA_DIR "/DCF/8SPXfqc6iL.tpk";
 758         int nRet = TADC_SUCCESS;
 759
 760         DrmFileMgr *pDrmFileMgr = NULL;
 761         DrmFileHandler *pDcfHandler = NULL;
 762
 763         unsigned char pCEK[CEK_SIZE + 1] = {0xBB, 0x87, 0x5D, 0xA8, 0x2C, 0xC4, 0x47, 0x81, 0x90, 0xBA, 0xD9, 0xB0, 0x0C, 0xD2, 0x94, 0xE9, 0x19, 0x0F, 0x24, 0x62, 0x5B, 0x0B, 0x49, 0x7A, 0xAE, 0x8E, 0x1D, 0x88, 0x7F, 0xF9, 0x96, 0xDB, 0x00};
 764         unsigned char pCID[32] = "8SPXfqc6iL-1.0.0";
 765
 766         long encryptionLevel = 17;
 767         long long encryptionRange = 10;
 768         long long plainTextSize = 705072;
 769         long long originalEndOffset = 705914;
 770
 771         printf("tc07_DrmFileMgrPositive_02() -------- Started! \n");
 772
 773         pDrmFileMgr = DrmFileMgr::GetInstance();
 774
 775         nRet = pDrmFileMgr->OpenFileHandler(pDCF, &second_key);
 776
 777         if (nRet != TADC_SUCCESS) {
 778                 printf("tc07_DrmFileMgrPositive_02 - OpenFileHandler() failed : key = %d, file = %s, %x\n",
 779                            second_key, pDCF, nRet);
 780                 goto CATCH;
 781         }
 782
 783         nRet = pDrmFileMgr->GetFileHandler(second_key, &pDcfHandler);
 784
 785         if (nRet != TADC_SUCCESS) {
 786                 printf("tc07_DrmFileMgrPositive_02 - GetFileHandler() failed : key = %d, file = %s, %x\n",
 787                            second_key, pDCF, nRet);
 788                 goto CATCH;
 789         }
 790
 791         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0) {
 792                 printf("tc07_DrmFileMgrPositive_02 - CEK Comparison failed : %s\n", pDCF);
 793                 goto CATCH;
 794         }
 795
 796         if (memcmp(pDCF, pDcfHandler->m_pFilePath,
 797                            strlen((char *)pDcfHandler->m_pFilePath)) != 0) {
 798                 printf("tc07_DrmFileMgrPositive_02 - FilePath Comparison failed : %s\n",
 799                            pDcfHandler->m_pFilePath);
 800                 goto CATCH;
 801         }
 802
 803         if (memcmp(pCID, pDcfHandler->m_pCID,
 804                            strlen((char *)pDcfHandler->m_pCID)) != 0) {
 805                 printf("tc07_DrmFileMgrPositive_02 - CID Comparison failed : %s\n",
 806                            pDcfHandler->m_pCID);
 807                 goto CATCH;
 808         }
 809
 810         if (pDcfHandler->m_encryptionLevel != encryptionLevel) {
 811                 printf("tc07_DrmFileMgrPositive_02 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n",
 812                            encryptionLevel, pDcfHandler->m_encryptionLevel);
 813                 goto CATCH;
 814         }
 815
 816         if (pDcfHandler->m_encryptionRange != encryptionRange) {
 817                 printf("tc07_DrmFileMgrPositive_02 - encryptionRange Comparison failed : origin = %lld, result = %lld\n",
 818                            encryptionRange, pDcfHandler->m_encryptionRange);
 819                 goto CATCH;
 820         }
 821
 822         if (pDcfHandler->m_plaintextSize != plainTextSize) {
 823                 printf("tc07_DrmFileMgrPositive_02 - plainTextSize Comparison failed : origin = %lld, result = %lld\n",
 824                            plainTextSize, pDcfHandler->m_plaintextSize);
 825                 goto CATCH;
 826         }
 827
 828         if (pDcfHandler->m_OriginEndOffset != originalEndOffset) {
 829                 printf("tc07_DrmFileMgrPositive_02 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n",
 830                            originalEndOffset, pDcfHandler->m_OriginEndOffset);
 831                 goto CATCH;
 832         }
 833
 834         printf("tc07_DrmFileMgrPositive_02 finished! -------- success \n");
 835
 836         return true;
 837
 838 CATCH:
 839
 840         return false;
 841 }
 842
 843 bool tc07_DrmFileMgrPositive_03(void)
 844 {
 845         const char *pDCF  = TEST_DATA_DIR "/DCF/FightGuiIF.tpk";
 846         int nRet = TADC_SUCCESS;
 847
 848         DrmFileMgr *pDrmFileMgr = NULL;
 849         DrmFileHandler *pDcfHandler = NULL;
 850
 851         unsigned char pCEK[CEK_SIZE + 1] = {0x34, 0x5A, 0x94, 0x28, 0xC3, 0xF4, 0x44, 0x3F, 0x86, 0x6D, 0xCF, 0xC5, 0x78, 0x1F, 0x23, 0xCE, 0xE9, 0x9B, 0xC4, 0x45, 0xA3, 0x30, 0x47, 0x1E, 0xB4, 0xE0, 0xAF, 0x96, 0x0F, 0xDE, 0xA9, 0xB4, 0x00};
 852
 853         unsigned char pCID[32] = "FightGuiIF-1.0.0";
 854
 855         long encryptionLevel = 17;
 856         long long encryptionRange = 10;
 857         long long plainTextSize = 45193789;
 858         long long originalEndOffset = 45194636;
 859
 860         printf("tc07_DrmFileMgrPositive_03() -------- Started! \n");
 861
 862         pDrmFileMgr = DrmFileMgr::GetInstance();
 863
 864         nRet = pDrmFileMgr->OpenFileHandler(pDCF, &third_key);
 865
 866         if (nRet != TADC_SUCCESS) {
 867                 printf("tc07_DrmFileMgrPositive_03 - OpenFileHandler() failed : key = %d, file = %s, %x\n",
 868                            third_key, pDCF, nRet);
 869                 goto CATCH;
 870         }
 871
 872         nRet = pDrmFileMgr->GetFileHandler(third_key, &pDcfHandler);
 873
 874         if (nRet != TADC_SUCCESS) {
 875                 printf("tc07_DrmFileMgrPositive_03 - GetFileHandler() failed : key = %d, file = %s, %x\n",
 876                            third_key, pDCF, nRet);
 877                 goto CATCH;
 878         }
 879
 880         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0) {
 881                 printf("tc07_DrmFileMgrPositive_03 - CEK Comparison failed : %s\n", pDCF);
 882                 goto CATCH;
 883         }
 884
 885         if (memcmp(pDCF, pDcfHandler->m_pFilePath,
 886                            strlen((char *)pDcfHandler->m_pFilePath)) != 0) {
 887                 printf("tc07_DrmFileMgrPositive_03 - FilePath Comparison failed : %s\n",
 888                            pDcfHandler->m_pFilePath);
 889                 goto CATCH;
 890         }
 891
 892         if (memcmp(pCID, pDcfHandler->m_pCID,
 893                            strlen((char *)pDcfHandler->m_pCID)) != 0) {
 894                 printf("tc07_DrmFileMgrPositive_03 - CID Comparison failed : %s\n",
 895                            pDcfHandler->m_pCID);
 896                 goto CATCH;
 897         }
 898
 899         if (pDcfHandler->m_encryptionLevel != encryptionLevel) {
 900                 printf("tc07_DrmFileMgrPositive_03 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n",
 901                            encryptionLevel, pDcfHandler->m_encryptionLevel);
 902                 goto CATCH;
 903         }
 904
 905         if (pDcfHandler->m_encryptionRange != encryptionRange) {
 906                 printf("tc07_DrmFileMgrPositive_03 - encryptionRange Comparison failed : origin = %lld, result = %lld\n",
 907                            encryptionRange, pDcfHandler->m_encryptionRange);
 908                 goto CATCH;
 909         }
 910
 911         if (pDcfHandler->m_plaintextSize != plainTextSize) {
 912                 printf("tc07_DrmFileMgrPositive_03 - plainTextSize Comparison failed : origin = %lld, result = %lld\n",
 913                            plainTextSize, pDcfHandler->m_plaintextSize);
 914                 goto CATCH;
 915         }
 916
 917         if (pDcfHandler->m_OriginEndOffset != originalEndOffset) {
 918                 printf("tc07_DrmFileMgrPositive_03 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n",
 919                            originalEndOffset, pDcfHandler->m_OriginEndOffset);
 920                 goto CATCH;
 921         }
 922
 923         printf("tc07_DrmFileMgrPositive_03 finished! -------- success \n");
 924
 925         return true;
 926
 927 CATCH:
 928
 929         return false;
 930 }
 931
 932 bool tc08_DrmFileMgrPositive_GetFileHandler_01(void)
 933 {
 934         const char *pDCF = TEST_DATA_DIR "/DCF/38EIfBurLJ.tpk";
 935         int nRet = TADC_SUCCESS;
 936
 937         DrmFileMgr *pDrmFileMgr = NULL;
 938         DrmFileHandler *pDcfHandler = NULL;
 939
 940         unsigned char pCEK[CEK_SIZE + 1] = {0xB1, 0x03, 0x4F, 0x30, 0xC8, 0x52, 0x45, 0x7E, 0x9D, 0xA2, 0x52, 0x25, 0x2E, 0xA9, 0x9B, 0x2B, 0x25, 0x36, 0xF1, 0x8D, 0x04, 0xD1, 0x4C, 0xE3, 0x96, 0x81, 0xD9, 0x98, 0xBB, 0xD7, 0x7E, 0xCA, 0x00};
 941
 942         unsigned char pCID[32] = "38EIfBurLJ-1.0.2";
 943
 944         long encryptionLevel = 17;
 945         long long encryptionRange = 10;
 946         long long plainTextSize = 1630724;
 947         long long originalEndOffset = 1631570;
 948
 949         printf("tc08_DrmFileMgrPositive_GetFileHandler_01() -------- Started! \n");
 950
 951         pDrmFileMgr = DrmFileMgr::GetInstance();
 952
 953         nRet = pDrmFileMgr->GetFileHandler(first_key, &pDcfHandler);
 954
 955         if (nRet != TADC_SUCCESS) {
 956                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 failed : key = %d, file = %s, %x\n",
 957                            first_key, pDCF, nRet);
 958                 goto CATCH;
 959         }
 960
 961         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0) {
 962                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 - CEK Comparison failed : %s\n",
 963                            pDCF);
 964                 goto CATCH;
 965         }
 966
 967         if (memcmp(pDCF, pDcfHandler->m_pFilePath,
 968                            strlen((char *)pDcfHandler->m_pFilePath)) != 0) {
 969                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 - FilePath Comparison failed : %s\n",
 970                            pDcfHandler->m_pFilePath);
 971                 goto CATCH;
 972         }
 973
 974         if (memcmp(pCID, pDcfHandler->m_pCID,
 975                            strlen((char *)pDcfHandler->m_pCID)) != 0) {
 976                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 - CID Comparison failed : %s\n",
 977                            pDcfHandler->m_pCID);
 978                 goto CATCH;
 979         }
 980
 981         if (pDcfHandler->m_encryptionLevel != encryptionLevel) {
 982                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n",
 983                            encryptionLevel, pDcfHandler->m_encryptionLevel);
 984                 goto CATCH;
 985         }
 986
 987         if (pDcfHandler->m_encryptionRange != encryptionRange) {
 988                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 - encryptionRange Comparison failed : origin = %lld, result = %lld\n",
 989                            encryptionRange, pDcfHandler->m_encryptionRange);
 990                 goto CATCH;
 991         }
 992
 993         if (pDcfHandler->m_plaintextSize != plainTextSize) {
 994                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 - plainTextSize Comparison failed : origin = %lld, result = %lld\n",
 995                            plainTextSize, pDcfHandler->m_plaintextSize);
 996                 goto CATCH;
 997         }
 998
 999         if (pDcfHandler->m_OriginEndOffset != originalEndOffset) {
1000                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n",
1001                            originalEndOffset, pDcfHandler->m_OriginEndOffset);
1002                 goto CATCH;
1003         }
1004
1005         printf("tc08_DrmFileMgrPositive_GetFileHandler_01 finished! -------- success \n");
1006
1007         return true;
1008
1009 CATCH:
1010
1011         return false;
1012 }
1013
1014 bool tc08_DrmFileMgrPositive_GetFileHandler_02(void)
1015 {
1016         const char *pDCF = TEST_DATA_DIR "/DCF/8SPXfqc6iL.tpk";
1017         int nRet = TADC_SUCCESS;
1018
1019         DrmFileMgr *pDrmFileMgr = NULL;
1020         DrmFileHandler *pDcfHandler = NULL;
1021
1022         unsigned char pCEK[CEK_SIZE + 1] = {0xBB, 0x87, 0x5D, 0xA8, 0x2C, 0xC4, 0x47, 0x81, 0x90, 0xBA, 0xD9, 0xB0, 0x0C, 0xD2, 0x94, 0xE9, 0x19, 0x0F, 0x24, 0x62, 0x5B, 0x0B, 0x49, 0x7A, 0xAE, 0x8E, 0x1D, 0x88, 0x7F, 0xF9, 0x96, 0xDB, 0x00};
1023
1024         unsigned char pCID[32] = "8SPXfqc6iL-1.0.0";
1025
1026         long encryptionLevel = 17;
1027         long long encryptionRange = 10;
1028         long long plainTextSize = 705072;
1029         long long originalEndOffset = 705914;
1030
1031         printf("tc08_DrmFileMgrPositive_GetFileHandler_02() -------- Started! \n");
1032
1033         pDrmFileMgr = DrmFileMgr::GetInstance();
1034
1035         nRet = pDrmFileMgr->GetFileHandler(second_key, &pDcfHandler);
1036
1037         if (nRet != TADC_SUCCESS) {
1038                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 failed : key = %d, file = %s, %x\n",
1039                            second_key, pDCF, nRet);
1040                 goto CATCH;
1041         }
1042
1043         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0) {
1044                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 - CEK Comparison failed : %s\n",
1045                            pDCF);
1046                 goto CATCH;
1047         }
1048
1049         if (memcmp(pDCF, pDcfHandler->m_pFilePath,
1050                            strlen((char *)pDcfHandler->m_pFilePath)) != 0) {
1051                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 - FilePath Comparison failed : %s\n",
1052                            pDcfHandler->m_pFilePath);
1053                 goto CATCH;
1054         }
1055
1056         if (memcmp(pCID, pDcfHandler->m_pCID,
1057                            strlen((char *)pDcfHandler->m_pCID)) != 0) {
1058                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 - CID Comparison failed : %s\n",
1059                            pDcfHandler->m_pCID);
1060                 goto CATCH;
1061         }
1062
1063         if (pDcfHandler->m_encryptionLevel != encryptionLevel) {
1064                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n",
1065                            encryptionLevel, pDcfHandler->m_encryptionLevel);
1066                 goto CATCH;
1067         }
1068
1069         if (pDcfHandler->m_encryptionRange != encryptionRange) {
1070                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 - encryptionRange Comparison failed : origin = %lld, result = %lld\n",
1071                            encryptionRange, pDcfHandler->m_encryptionRange);
1072                 goto CATCH;
1073         }
1074
1075         if (pDcfHandler->m_plaintextSize != plainTextSize) {
1076                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 - plainTextSize Comparison failed : origin = %lld, result = %lld\n",
1077                            plainTextSize, pDcfHandler->m_plaintextSize);
1078                 goto CATCH;
1079         }
1080
1081         if (pDcfHandler->m_OriginEndOffset != originalEndOffset) {
1082                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n",
1083                            originalEndOffset, pDcfHandler->m_OriginEndOffset);
1084                 goto CATCH;
1085         }
1086
1087         printf("tc08_DrmFileMgrPositive_GetFileHandler_02 finished! -------- success \n");
1088
1089         return true;
1090
1091 CATCH:
1092
1093         return false;
1094 }
1095
1096 bool tc08_DrmFileMgrPositive_GetFileHandler_03(void)
1097 {
1098         const char *pDCF = TEST_DATA_DIR "/DCF/FightGuiIF.tpk";
1099         int nRet = TADC_SUCCESS;
1100
1101         DrmFileMgr *pDrmFileMgr = NULL;
1102         DrmFileHandler *pDcfHandler = NULL;
1103
1104         unsigned char pCEK[CEK_SIZE + 1] = {0x34, 0x5A, 0x94, 0x28, 0xC3, 0xF4, 0x44, 0x3F, 0x86, 0x6D, 0xCF, 0xC5, 0x78, 0x1F, 0x23, 0xCE, 0xE9, 0x9B, 0xC4, 0x45, 0xA3, 0x30, 0x47, 0x1E, 0xB4, 0xE0, 0xAF, 0x96, 0x0F, 0xDE, 0xA9, 0xB4, 0x00};
1105
1106         unsigned char pCID[32] = "FightGuiIF-1.0.0";
1107
1108         long encryptionLevel = 17;
1109         long long encryptionRange = 10;
1110         long long plainTextSize = 45193789;
1111         long long originalEndOffset = 45194636;
1112
1113         printf("tc08_DrmFileMgrPositive_GetFileHandler_03() -------- Started! \n");
1114
1115         pDrmFileMgr = DrmFileMgr::GetInstance();
1116
1117         nRet = pDrmFileMgr->GetFileHandler(third_key, &pDcfHandler);
1118
1119         if (nRet != TADC_SUCCESS) {
1120                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 failed : key = %d, file = %s, %x\n",
1121                            third_key, pDCF, nRet);
1122                 goto CATCH;
1123         }
1124
1125         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0) {
1126                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 - CEK Comparison failed : %s\n",
1127                            pDCF);
1128                 goto CATCH;
1129         }
1130
1131         if (memcmp(pDCF, pDcfHandler->m_pFilePath,
1132                            strlen((char *)pDcfHandler->m_pFilePath)) != 0) {
1133                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 - FilePath Comparison failed : %s\n",
1134                            pDcfHandler->m_pFilePath);
1135                 goto CATCH;
1136         }
1137
1138         if (memcmp(pCID, pDcfHandler->m_pCID,
1139                            strlen((char *)pDcfHandler->m_pCID)) != 0) {
1140                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 - CID Comparison failed : %s\n",
1141                            pDcfHandler->m_pCID);
1142                 goto CATCH;
1143         }
1144
1145         if (pDcfHandler->m_encryptionLevel != encryptionLevel) {
1146                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n",
1147                            encryptionLevel, pDcfHandler->m_encryptionLevel);
1148                 goto CATCH;
1149         }
1150
1151         if (pDcfHandler->m_encryptionRange != encryptionRange) {
1152                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 - encryptionRange Comparison failed : origin = %lld, result = %lld\n",
1153                            encryptionRange, pDcfHandler->m_encryptionRange);
1154                 goto CATCH;
1155         }
1156
1157         if (pDcfHandler->m_plaintextSize != plainTextSize) {
1158                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 - plainTextSize Comparison failed : origin = %lld, result = %lld\n",
1159                            plainTextSize, pDcfHandler->m_plaintextSize);
1160                 goto CATCH;
1161         }
1162
1163         if (pDcfHandler->m_OriginEndOffset != originalEndOffset) {
1164                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n",
1165                            originalEndOffset, pDcfHandler->m_OriginEndOffset);
1166                 goto CATCH;
1167         }
1168
1169         printf("tc08_DrmFileMgrPositive_GetFileHandler_03 finished! -------- success \n");
1170
1171         return true;
1172
1173 CATCH:
1174
1175         return false;
1176 }
1177
1178 bool tc09_DrmFileMgrPositive_FileAPI_01(void)
1179 {
1180         const char *pDCF = TEST_DATA_DIR "/DCF/38EIfBurLJ.tpk";
1181         int nRet = TADC_SUCCESS;
1182
1183         DrmFileMgr *pDrmFileMgr = NULL;
1184         DrmFileHandler *pDcfHandler = NULL;
1185
1186         long long originalEndOffset = 1631570;
1187         long long DrmCurOffset = 0;
1188         long long OriginCurOffset = 846;
1189         long long i = 0;
1190
1191         printf("tc09_DrmFileMgrPositive_FileAPI_01() -------- Started! \n");
1192
1193         pDrmFileMgr = DrmFileMgr::GetInstance();
1194
1195         nRet = pDrmFileMgr->GetFileHandler(first_key, &pDcfHandler);
1196
1197         if (nRet != TADC_SUCCESS) {
1198                 printf("tc09_DrmFileMgrPositive_FileAPI_01 failed : key = %d, file = %s, %x\n",
1199                            first_key, pDCF, nRet);
1200                 goto CATCH;
1201         }
1202
1203         if (pDcfHandler->m_OriginEndOffset != originalEndOffset) {
1204                 printf("tc09_DrmFileMgrPositive_FileAPI_01 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n",
1205                            originalEndOffset, pDcfHandler->m_OriginEndOffset);
1206                 goto CATCH;
1207         }
1208
1209         if (OriginCurOffset != pDcfHandler->m_OriginCurOffset) {
1210                 printf("tc09_DrmFileMgrPositive_FileAPI_01 - originalCurOffset Comparison failed : origin = %lld, result = %lld\n",
1211                            OriginCurOffset, pDcfHandler->m_OriginCurOffset);
1212                 goto CATCH;
1213         }
1214
1215         for (i = 0; i <= pDcfHandler->m_DrmEndOffset; i++) {
1216                 nRet = pDcfHandler->DrmSeek(i, SEEK_SET);
1217
1218                 if (nRet != TADC_SUCCESS) {
1219                         printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_SET, forward) : key = %d, file = %s, i = %lld, ret = %x\n",
1220                                    first_key, pDCF, i, nRet);
1221                         goto CATCH;
1222                 }
1223
1224                 DrmCurOffset = pDcfHandler->DrmTell();
1225
1226                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1227                         printf("tc09_DrmFileMgrPositive_FileAPI_01 - DrmCurOffset Comparison failed (SEEK_SET, forward) : origin = %lld, result = %lld, i = %lld\n",
1228                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1229                         goto CATCH;
1230                 }
1231         }
1232
1233         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset) {
1234                 printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_SET, forward), DrmCurOffset = %lld, RealEndOffset = %lld, %x\n",
1235                            DrmCurOffset, pDcfHandler->m_DrmEndOffset, nRet);
1236                 goto CATCH;
1237         }
1238
1239         for (i = pDcfHandler->m_DrmEndOffset; i >= 0; i--) {
1240                 nRet = pDcfHandler->DrmSeek(i, SEEK_SET);
1241
1242                 if (nRet != TADC_SUCCESS) {
1243                         printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_SET, backward) : key=%d, file=%s, i=%lld, %x\n",
1244                                    first_key, pDCF, i, nRet);
1245                         goto CATCH;
1246                 }
1247
1248                 DrmCurOffset = pDcfHandler->DrmTell();
1249
1250                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1251                         printf("tc09_DrmFileMgrPositive_FileAPI_01 - DrmCurOffset Comparison failed (SEEK_SET, backward) : origin = %lld, result = %lld, i=%lld\n",
1252                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1253                         goto CATCH;
1254                 }
1255         }
1256
1257         if (DrmCurOffset != 0) {
1258                 printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_SET, backward), DrmCurOffset = %lld, %x\n",
1259                            DrmCurOffset, nRet);
1260                 goto CATCH;
1261         }
1262
1263         for (i = 0; i <= pDcfHandler->m_DrmEndOffset; i++) {
1264                 nRet = pDcfHandler->DrmSeek(-i, SEEK_END);
1265
1266                 if (nRet != TADC_SUCCESS) {
1267                         printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_END, forward) : key=%d, file=%s, i=%lld, %x\n",
1268                                    first_key, pDCF, i, nRet);
1269                         goto CATCH;
1270                 }
1271
1272                 DrmCurOffset = pDcfHandler->DrmTell();
1273
1274                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1275                         printf("tc09_DrmFileMgrPositive_FileAPI_01 - DrmCurOffset Comparison failed (SEEK_END, forward) : origin = %lld, result = %lld, i = %lld\n",
1276                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1277                         goto CATCH;
1278                 }
1279         }
1280
1281         if (DrmCurOffset != 0) {
1282                 printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_END, forward), DrmCurOffset = %lld, %x\n",
1283                            DrmCurOffset, nRet);
1284                 goto CATCH;
1285         }
1286
1287         for (i = pDcfHandler->m_DrmEndOffset; i >= 0; i--) {
1288                 nRet = pDcfHandler->DrmSeek(-i, SEEK_END);
1289
1290                 if (nRet != TADC_SUCCESS) {
1291                         printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_END, backward) : key=%d, file=%s, i=%lld, %x\n",
1292                                    first_key, pDCF, i, nRet);
1293                         goto CATCH;
1294                 }
1295
1296                 DrmCurOffset = pDcfHandler->DrmTell();
1297
1298                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1299                         printf("tc09_DrmFileMgrPositive_FileAPI_01 - DrmCurOffset Comparison failed (SEEK_END, backward) : origin = %lld, result = %lld, i = %lld\n",
1300                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1301                         goto CATCH;
1302                 }
1303         }
1304
1305         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset) {
1306                 printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_END, backward), DrmCurOffset = %lld, RealEndOffset = %lld, %x\n",
1307                            DrmCurOffset, pDcfHandler->m_DrmEndOffset, nRet);
1308                 goto CATCH;
1309         }
1310
1311         for (i = 0; i < pDcfHandler->m_DrmEndOffset; i++) {
1312                 nRet = pDcfHandler->DrmSeek(-1, SEEK_CUR);
1313
1314                 if (nRet != TADC_SUCCESS) {
1315                         printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_CUR, forward) : key=%d, file=%s, i=%lld, %x\n",
1316                                    first_key, pDCF, i, nRet);
1317                         goto CATCH;
1318                 }
1319
1320                 DrmCurOffset = pDcfHandler->DrmTell();
1321
1322                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1323                         printf("tc09_DrmFileMgrPositive_FileAPI_01 - DrmCurOffset Comparison failed : origin=%lld, result=%lld\n",
1324                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset);
1325                         goto CATCH;
1326                 }
1327         }
1328
1329         if (DrmCurOffset != 0) {
1330                 printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_CUR, forward), DrmCurOffset = %lld, %x\n",
1331                            DrmCurOffset, nRet);
1332                 goto CATCH;
1333         }
1334
1335         for (i = 0; i < pDcfHandler->m_DrmEndOffset; i++) {
1336                 nRet = pDcfHandler->DrmSeek(1, SEEK_CUR);
1337
1338                 if (nRet != TADC_SUCCESS) {
1339                         printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_CUR, backward) : key=%d, file=%s, i=%lld, %x\n",
1340                                    first_key, pDCF, i, nRet);
1341                         goto CATCH;
1342                 }
1343
1344                 DrmCurOffset = pDcfHandler->DrmTell();
1345
1346                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1347                         printf("tc09_DrmFileMgrPositive_FileAPI_01 - DrmCurOffset Comparison failed (SEEK_CUR, backward) : origin = %lld, result = %lld, i = %lld\n",
1348                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1349                         goto CATCH;
1350                 }
1351         }
1352
1353         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset) {
1354                 printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_CUR, backward), DrmCurOffset = %lld, %x\n",
1355                            DrmCurOffset, nRet);
1356                 goto CATCH;
1357         }
1358
1359         printf("tc09_DrmFileMgrPositive_FileAPI_01 finished! -------- success \n");
1360
1361         return true;
1362
1363 CATCH:
1364         return false;
1365 }
1366
1367 bool tc09_DrmFileMgrPositive_FileAPI_02(void)
1368 {
1369         const char *pDCF = TEST_DATA_DIR "/DCF/8SPXfqc6iL.tpk";
1370         int nRet = TADC_SUCCESS;
1371
1372         DrmFileMgr *pDrmFileMgr = NULL;
1373         DrmFileHandler *pDcfHandler = NULL;
1374
1375         long long originalEndOffset = 705914;
1376         long long DrmCurOffset = 0;
1377         long long OriginCurOffset = 842;
1378         long long i = 0;
1379
1380         printf("tc09_DrmFileMgrPositive_FileAPI_02() -------- Started! \n");
1381
1382         pDrmFileMgr = DrmFileMgr::GetInstance();
1383
1384         nRet = pDrmFileMgr->GetFileHandler(second_key, &pDcfHandler);
1385
1386         if (nRet != TADC_SUCCESS) {
1387                 printf("tc09_DrmFileMgrPositive_FileAPI_02 failed : key = %d, file = %s, %x\n",
1388                            second_key, pDCF, nRet);
1389                 goto CATCH;
1390         }
1391
1392         if (pDcfHandler->m_OriginEndOffset != originalEndOffset) {
1393                 printf("tc09_DrmFileMgrPositive_FileAPI_02 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n",
1394                            originalEndOffset, pDcfHandler->m_OriginEndOffset);
1395                 goto CATCH;
1396         }
1397
1398         if (OriginCurOffset != pDcfHandler->m_OriginCurOffset) {
1399                 printf("tc09_DrmFileMgrPositive_FileAPI_02 - originalCurOffset Comparison failed : origin = %lld, result = %lld\n",
1400                            OriginCurOffset, pDcfHandler->m_OriginCurOffset);
1401                 goto CATCH;
1402         }
1403
1404         for (i = 0; i <= pDcfHandler->m_DrmEndOffset; i++) {
1405                 nRet = pDcfHandler->DrmSeek(i, SEEK_SET);
1406
1407                 if (nRet != TADC_SUCCESS) {
1408                         printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_SET, forward) : key = %d, file = %s, i = %lld, ret = %x\n",
1409                                    second_key, pDCF, i, nRet);
1410                         goto CATCH;
1411                 }
1412
1413                 DrmCurOffset = pDcfHandler->DrmTell();
1414
1415                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1416                         printf("tc09_DrmFileMgrPositive_FileAPI_02 - DrmCurOffset Comparison failed (SEEK_SET, forward : origin = %lld, result = %lld, i = %lld\n",
1417                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1418                         goto CATCH;
1419                 }
1420         }
1421
1422         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset) {
1423                 printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_SET, forward), DrmCurOffset = %lld, RealEndOffset = %lld, %x\n",
1424                            DrmCurOffset, pDcfHandler->m_DrmEndOffset, nRet);
1425                 goto CATCH;
1426         }
1427
1428         for (i = pDcfHandler->m_DrmEndOffset; i >= 0; i--) {
1429                 nRet = pDcfHandler->DrmSeek(i, SEEK_SET);
1430
1431                 if (nRet != TADC_SUCCESS) {
1432                         printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_SET, backward) : key=%d, file=%s, i=%lld, %x\n",
1433                                    second_key, pDCF, i, nRet);
1434                         goto CATCH;
1435                 }
1436
1437                 DrmCurOffset = pDcfHandler->DrmTell();
1438
1439                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1440                         printf("tc09_DrmFileMgrPositive_FileAPI_02 - DrmCurOffset Comparison failed (SEEK_SET, backward) : origin = %lld, result = %lld, i = %lld\n",
1441                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1442                         goto CATCH;
1443                 }
1444         }
1445
1446         if (DrmCurOffset != 0) {
1447                 printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_SET, backward), DrmCurOffset = %lld, %x\n",
1448                            DrmCurOffset, nRet);
1449                 goto CATCH;
1450         }
1451
1452         for (i = 0; i <= pDcfHandler->m_DrmEndOffset; i++) {
1453                 nRet = pDcfHandler->DrmSeek(-i, SEEK_END);
1454
1455                 if (nRet != TADC_SUCCESS) {
1456                         printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_END, forward) : key=%d, file=%s, i=%lld, %x\n",
1457                                    second_key, pDCF, i, nRet);
1458                         goto CATCH;
1459                 }
1460
1461                 DrmCurOffset = pDcfHandler->DrmTell();
1462
1463                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1464                         printf("tc09_DrmFileMgrPositive_FileAPI_02 - DrmCurOffset Comparison failed (SEEK_END, forward) : origin = %lld, result = %lld, i = %lld\n",
1465                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1466                         goto CATCH;
1467                 }
1468         }
1469
1470         if (DrmCurOffset != 0) {
1471                 printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_END, forward), DrmCurOffset = %lld, %x\n",
1472                            DrmCurOffset, nRet);
1473                 goto CATCH;
1474         }
1475
1476         for (i = pDcfHandler->m_DrmEndOffset; i >= 0; i--) {
1477                 nRet = pDcfHandler->DrmSeek(-i, SEEK_END);
1478
1479                 if (nRet != TADC_SUCCESS) {
1480                         printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_END, backward) : key=%d, file=%s, i=%lld, %x\n",
1481                                    second_key, pDCF, i, nRet);
1482                         goto CATCH;
1483                 }
1484
1485                 DrmCurOffset = pDcfHandler->DrmTell();
1486
1487                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1488                         printf("tc09_DrmFileMgrPositive_FileAPI_02 - DrmCurOffset Comparison failed (SEEK_END, backward) : origin = %lld, result = %lld, i = %lld\n",
1489                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1490                         goto CATCH;
1491                 }
1492         }
1493
1494         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset) {
1495                 printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_END, backward), DrmCurOffset = %lld, RealEndOffset = %lld, %x\n",
1496                            DrmCurOffset, pDcfHandler->m_DrmEndOffset, nRet);
1497                 goto CATCH;
1498         }
1499
1500         for (i = 0; i < pDcfHandler->m_DrmEndOffset; i++) {
1501                 nRet = pDcfHandler->DrmSeek(-1, SEEK_CUR);
1502
1503                 if (nRet != TADC_SUCCESS) {
1504                         printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_CUR, forward) : key=%d, file=%s, i=%lld, %x\n",
1505                                    second_key, pDCF, i, nRet);
1506                         goto CATCH;
1507                 }
1508
1509                 DrmCurOffset = pDcfHandler->DrmTell();
1510
1511                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1512                         printf("tc09_DrmFileMgrPositive_FileAPI_02 - DrmCurOffset Comparison failed : origin=%lld, result=%lld\n",
1513                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset);
1514                         goto CATCH;
1515                 }
1516         }
1517
1518         if (DrmCurOffset != 0) {
1519                 printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_CUR, forward), DrmCurOffset = %lld, %x\n",
1520                            DrmCurOffset, nRet);
1521                 goto CATCH;
1522         }
1523
1524         for (i = 0; i < pDcfHandler->m_DrmEndOffset; i++) {
1525                 nRet = pDcfHandler->DrmSeek(1, SEEK_CUR);
1526
1527                 if (nRet != TADC_SUCCESS) {
1528                         printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_CUR, backward) : key=%d, file=%s, i=%lld, %x\n",
1529                                    second_key, pDCF, i, nRet);
1530                         goto CATCH;
1531                 }
1532
1533                 DrmCurOffset = pDcfHandler->DrmTell();
1534
1535                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1536                         printf("tc09_DrmFileMgrPositive_FileAPI_02 - DrmCurOffset Comparison failed (SEEK_CUR, backward) : origin = %lld, result = %lld, i = %lld\n",
1537                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1538                         goto CATCH;
1539                 }
1540         }
1541
1542         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset) {
1543                 printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_CUR, backward), DrmCurOffset = %lld, %x\n",
1544                            DrmCurOffset, nRet);
1545                 goto CATCH;
1546         }
1547
1548         printf("tc09_DrmFileMgrPositive_FileAPI_02 finished! -------- success \n");
1549
1550         return true;
1551
1552 CATCH:
1553         return false;
1554 }
1555
1556 bool tc09_DrmFileMgrPositive_FileAPI_03(void)
1557 {
1558         const char *pDCF = TEST_DATA_DIR "/DCF/FightGuiIF.tpk";
1559         int nRet = TADC_SUCCESS;
1560
1561         DrmFileMgr *pDrmFileMgr = NULL;
1562         DrmFileHandler *pDcfHandler = NULL;
1563
1564         long long originalEndOffset = 45194636;
1565         long long DrmCurOffset = 0;
1566         long long OriginCurOffset = 847;
1567         long long i = 0;
1568
1569         printf("tc09_DrmFileMgrPositive_FileAPI_03() -------- Started! \n");
1570
1571         pDrmFileMgr = DrmFileMgr::GetInstance();
1572
1573         nRet = pDrmFileMgr->GetFileHandler(third_key, &pDcfHandler);
1574
1575         if (nRet != TADC_SUCCESS) {
1576                 printf("tc09_DrmFileMgrPositive_FileAPI_03 failed : key = %d, file = %s, %x\n",
1577                            third_key, pDCF, nRet);
1578                 goto CATCH;
1579         }
1580
1581         if (pDcfHandler->m_OriginEndOffset != originalEndOffset) {
1582                 printf("tc09_DrmFileMgrPositive_FileAPI_03 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n",
1583                            originalEndOffset, pDcfHandler->m_OriginEndOffset);
1584                 goto CATCH;
1585         }
1586
1587         if (OriginCurOffset != pDcfHandler->m_OriginCurOffset) {
1588                 printf("tc09_DrmFileMgrPositive_FileAPI_03 - originalCurOffset Comparison failed : origin = %lld, result = %lld\n",
1589                            OriginCurOffset, pDcfHandler->m_OriginCurOffset);
1590                 goto CATCH;
1591         }
1592
1593         for (i = 0; i <= pDcfHandler->m_DrmEndOffset; i++) {
1594                 nRet = pDcfHandler->DrmSeek(i, SEEK_SET);
1595
1596                 if (nRet != TADC_SUCCESS) {
1597                         printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_SET, forward) : key = %d, file = %s, i = %lld, ret = %x\n",
1598                                    third_key, pDCF, i, nRet);
1599                         goto CATCH;
1600                 }
1601
1602                 DrmCurOffset = pDcfHandler->DrmTell();
1603
1604                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1605                         printf("tc09_DrmFileMgrPositive_FileAPI_03 - DrmCurOffset Comparison failed (SEEK_SET, forward) : origin = %lld, result = %lld, i = %lld\n",
1606                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1607                         goto CATCH;
1608                 }
1609         }
1610
1611         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset) {
1612                 printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_SET, forward), DrmCurOffset = %lld, RealEndOffset = %lld, %x\n",
1613                            DrmCurOffset, pDcfHandler->m_DrmEndOffset, nRet);
1614                 goto CATCH;
1615         }
1616
1617         for (i = pDcfHandler->m_DrmEndOffset; i >= 0; i--) {
1618                 nRet = pDcfHandler->DrmSeek(i, SEEK_SET);
1619
1620                 if (nRet != TADC_SUCCESS) {
1621                         printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_SET, backward) : key=%d, file=%s, i=%lld, %x\n",
1622                                    third_key, pDCF, i, nRet);
1623                         goto CATCH;
1624                 }
1625
1626                 DrmCurOffset = pDcfHandler->DrmTell();
1627
1628                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1629                         printf("tc09_DrmFileMgrPositive_FileAPI_03 - DrmCurOffset Comparison failed (SEEK_SET, backward) : origin = %lld, result = %lld, i = %lld\n",
1630                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1631                         goto CATCH;
1632                 }
1633         }
1634
1635         if (DrmCurOffset != 0) {
1636                 printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_SET, backward), DrmCurOffset = %lld, %x\n",
1637                            DrmCurOffset, nRet);
1638                 goto CATCH;
1639         }
1640
1641         for (i = 0; i <= pDcfHandler->m_DrmEndOffset; i++) {
1642                 nRet = pDcfHandler->DrmSeek(-i, SEEK_END);
1643
1644                 if (nRet != TADC_SUCCESS) {
1645                         printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_END, forward) : key=%d, file=%s, i=%lld, %x\n",
1646                                    third_key, pDCF, i, nRet);
1647                         goto CATCH;
1648                 }
1649
1650                 DrmCurOffset = pDcfHandler->DrmTell();
1651
1652                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1653                         printf("tc09_DrmFileMgrPositive_FileAPI_03 - DrmCurOffset Comparison failed (SEEK_END, forward) : origin = %lld, result = %lld, i = %lld\n",
1654                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1655                         goto CATCH;
1656                 }
1657         }
1658
1659         if (DrmCurOffset != 0) {
1660                 printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_END, forward), DrmCurOffset = %lld, %x\n",
1661                            DrmCurOffset, nRet);
1662                 goto CATCH;
1663         }
1664
1665         for (i = pDcfHandler->m_DrmEndOffset; i >= 0; i--) {
1666                 nRet = pDcfHandler->DrmSeek(-i, SEEK_END);
1667
1668                 if (nRet != TADC_SUCCESS) {
1669                         printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_END, backward) : key=%d, file=%s, i=%lld, %x\n",
1670                                    third_key, pDCF, i, nRet);
1671                         goto CATCH;
1672                 }
1673
1674                 DrmCurOffset = pDcfHandler->DrmTell();
1675
1676                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1677                         printf("tc09_DrmFileMgrPositive_FileAPI_03 - DrmCurOffset Comparison failed (SEEK_END, backward) : origin = %lld, result = %lld, i = %lld\n",
1678                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1679                         goto CATCH;
1680                 }
1681         }
1682
1683         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset) {
1684                 printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_END, backward), DrmCurOffset = %lld, RealEndOffset = %lld, %x\n",
1685                            DrmCurOffset, pDcfHandler->m_DrmEndOffset, nRet);
1686                 goto CATCH;
1687         }
1688
1689         for (i = 0; i < pDcfHandler->m_DrmEndOffset; i++) {
1690                 nRet = pDcfHandler->DrmSeek(-1, SEEK_CUR);
1691
1692                 if (nRet != TADC_SUCCESS) {
1693                         printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_CUR, forward) : key=%d, file=%s, i=%lld, %x\n",
1694                                    third_key, pDCF, i, nRet);
1695                         goto CATCH;
1696                 }
1697
1698                 DrmCurOffset = pDcfHandler->DrmTell();
1699
1700                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1701                         printf("tc09_DrmFileMgrPositive_FileAPI_03 - DrmCurOffset Comparison failed : origin=%lld, result=%lld\n",
1702                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset);
1703                         goto CATCH;
1704                 }
1705         }
1706
1707         if (DrmCurOffset != 0) {
1708                 printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_CUR, forward), DrmCurOffset = %lld, %x\n",
1709                            DrmCurOffset, nRet);
1710                 goto CATCH;
1711         }
1712
1713         for (i = 0; i < pDcfHandler->m_DrmEndOffset; i++) {
1714                 nRet = pDcfHandler->DrmSeek(1, SEEK_CUR);
1715
1716                 if (nRet != TADC_SUCCESS) {
1717                         printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_CUR, backward) : key=%d, file=%s, i=%lld, %x\n",
1718                                    third_key, pDCF, i, nRet);
1719                         goto CATCH;
1720                 }
1721
1722                 DrmCurOffset = pDcfHandler->DrmTell();
1723
1724                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset) {
1725                         printf("tc09_DrmFileMgrPositive_FileAPI_03 - DrmCurOffset Comparison failed (SEEK_CUR, backward) : origin = %lld, result = %lld, i = %lld\n",
1726                                    DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1727                         goto CATCH;
1728                 }
1729         }
1730
1731         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset) {
1732                 printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_CUR, backward), DrmCurOffset = %lld, %x\n",
1733                            DrmCurOffset, nRet);
1734                 goto CATCH;
1735         }
1736
1737         printf("tc09_DrmFileMgrPositive_FileAPI_03 finished! -------- success \n");
1738
1739         return true;
1740
1741 CATCH:
1742         return false;
1743 }
1744
1745 bool tc10_DrmFileMgrPositive_CloseFileHandler_01(void)
1746 {
1747         int nRet = TADC_SUCCESS;
1748
1749         DrmFileMgr *pDrmFileMgr = NULL;
1750         DrmFileHandler *pDcfHandler = NULL;
1751
1752         printf("tc10_DrmFileMgrPositive_CloseFileHandler_01 -------- Started! \n");
1753
1754         pDrmFileMgr = DrmFileMgr::GetInstance();
1755
1756         nRet = pDrmFileMgr->GetFileHandler(first_key, &pDcfHandler);
1757
1758         if (nRet != TADC_SUCCESS) {
1759                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_01 failed : key = %d, ret=%x\n",
1760                            first_key, nRet);
1761                 goto CATCH;
1762         }
1763
1764         nRet = pDrmFileMgr->CloseFileHandler(first_key);
1765
1766         if (nRet != TADC_SUCCESS) {
1767                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_01 failed : key = %d, ret=%x\n",
1768                            first_key, nRet);
1769                 goto CATCH;
1770         }
1771
1772         nRet = pDrmFileMgr->GetFileHandler(first_key, &pDcfHandler);
1773
1774         if (nRet == TADC_SUCCESS) {
1775                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_01 failed : key = %d\n",
1776                            first_key);
1777                 goto CATCH;
1778         }
1779
1780         printf("tc10_DrmFileMgrPositive_CloseFileHandler_01 finished! -------- success \n");
1781
1782         return true;
1783
1784 CATCH:
1785         return false;
1786 }
1787
1788 bool tc10_DrmFileMgrPositive_CloseFileHandler_02(void)
1789 {
1790         int nRet = TADC_SUCCESS;
1791
1792         DrmFileMgr *pDrmFileMgr = NULL;
1793         DrmFileHandler *pDcfHandler = NULL;
1794
1795         printf("tc10_DrmFileMgrPositive_CloseFileHandler_02 -------- Started! \n");
1796
1797         pDrmFileMgr = DrmFileMgr::GetInstance();
1798
1799         nRet = pDrmFileMgr->GetFileHandler(second_key, &pDcfHandler);
1800
1801         if (nRet != TADC_SUCCESS) {
1802                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_02 failed : key = %d, ret=%x\n",
1803                            second_key, nRet);
1804                 goto CATCH;
1805         }
1806
1807         nRet = pDrmFileMgr->CloseFileHandler(second_key);
1808
1809         if (nRet != TADC_SUCCESS) {
1810                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_02 failed : key = %d, ret=%x\n",
1811                            second_key, nRet);
1812                 goto CATCH;
1813         }
1814
1815         nRet = pDrmFileMgr->GetFileHandler(second_key, &pDcfHandler);
1816
1817         if (nRet == TADC_SUCCESS) {
1818                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_02 failed : key = %d\n",
1819                            second_key);
1820                 goto CATCH;
1821         }
1822
1823         printf("tc10_DrmFileMgrPositive_CloseFileHandler_02 finished! -------- success \n");
1824
1825         return true;
1826
1827 CATCH:
1828         return false;
1829 }
1830
1831 bool tc10_DrmFileMgrPositive_CloseFileHandler_03(void)
1832 {
1833         int nRet = TADC_SUCCESS;
1834
1835         DrmFileMgr *pDrmFileMgr = NULL;
1836         DrmFileHandler *pDcfHandler = NULL;
1837
1838         printf("tc10_DrmFileMgrPositive_CloseFileHandler_03 -------- Started! \n");
1839
1840         pDrmFileMgr = DrmFileMgr::GetInstance();
1841
1842         nRet = pDrmFileMgr->GetFileHandler(third_key, &pDcfHandler);
1843
1844         if (nRet != TADC_SUCCESS) {
1845                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_03 failed : key = %d, ret=%x\n",
1846                            third_key, nRet);
1847                 goto CATCH;
1848         }
1849
1850         nRet = pDrmFileMgr->CloseFileHandler(third_key);
1851
1852         if (nRet != TADC_SUCCESS) {
1853                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_03 failed : key = %d, ret=%x\n",
1854                            third_key, nRet);
1855                 goto CATCH;
1856         }
1857
1858         nRet = pDrmFileMgr->GetFileHandler(third_key, &pDcfHandler);
1859
1860         if (nRet == TADC_SUCCESS) {
1861                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_03 failed : key = %d\n",
1862                            third_key);
1863                 goto CATCH;
1864         }
1865
1866         printf("tc10_DrmFileMgrPositive_CloseFileHandler_03 finished! -------- success \n");
1867
1868         return true;
1869
1870 CATCH:
1871         return false;
1872 }
1873
1874 bool tc11_GetDeviceId_01(void)
1875 {
1876         unsigned char DUID[33] = {0, };
1877         int nRet = 0;
1878
1879         printf("tc11_GetDeviceID_01() -------- Started! \n");
1880
1881         nRet = TADC_IF_GetDUID((char *)DUID);
1882
1883         if (nRet != TADC_SUCCESS) {
1884                 printf("tc11_GetDeviceID_01() failed.");
1885                 return false;
1886         }
1887
1888         printf("DUID=%s\n", (char *)DUID);
1889         printf("tc11_GetDeviceID_01() finished! -------- success \n");
1890
1891         return true;
1892 }
1893
1894 bool tc12_TADC_SetDeviceInfo_01(void)
1895 {
1896         int nRet = TADC_SUCCESS;
1897         T_DEVICE_INFO   t_DeviceInfo;
1898
1899         printf("tc12_TADC_SetDeviceInfo_01() -------- Started! \n");
1900
1901         nRet = TADC_SetDeviceInfo(&t_DeviceInfo);
1902
1903         if (nRet != TADC_SUCCESS) {
1904                 printf("tc12_TADC_SetDeviceInfo_01() failed.\n");
1905                 return false;
1906         }
1907
1908         printf("DUID=%s\n", (char *)t_DeviceInfo.DUID);
1909         printf("tc12_TADC_SetDeviceInfo_01() finished! -------- success \n");
1910
1911         return true;
1912 }
1913
1914 bool tc13_DTappsInstallLicense_01(void)
1915 {
1916         printf("tc13_DTappsInstallLicense_01() -------- Started! \n");
1917
1918         const char *pFirstRo = TEST_DATA_DIR "/RO/38EIfBurLJ-1.0.2.ro";
1919
1920         auto buf = _read_ro_file(pFirstRo);
1921
1922         int nRet = DTappsInstallLicense(reinterpret_cast<char *>(buf.data()));
1923
1924         if (nRet != TADC_SUCCESS) {
1925                 printf("tc13_DTappsInstallLicense_01() failed. nRet=%d\n", nRet);
1926                 return false;
1927         }
1928
1929         printf("tc13_DTappsInstallLicense_01() finished! -------- success \n");
1930         return true;
1931 }
1932
1933 bool tc13_DTappsInstallLicense_02(void)
1934 {
1935         printf("tc13_DTappsInstallLicense_02() -------- Started! \n");
1936
1937         const char *pFirstRo = TEST_DATA_DIR "/RO/8SPXfqc6iL-1.0.0.ro";
1938
1939         auto buf = _read_ro_file(pFirstRo);
1940
1941         int nRet = DTappsInstallLicense(reinterpret_cast<char *>(buf.data()));
1942
1943         if (nRet != TADC_SUCCESS) {
1944                 printf("tc13_DTappsInstallLicense_02() failed. nRet=%d\n", nRet);
1945                 return false;
1946         }
1947
1948         printf("tc13_DTappsInstallLicense_02() finished! -------- success \n");
1949         return true;
1950 }
1951
1952 bool tc13_DTappsInstallLicense_03(void)
1953 {
1954         printf("tc13_DTappsInstallLicense_03() -------- Started! \n");
1955
1956         const char *pFirstRo = TEST_DATA_DIR "/RO/FightGuiIF-1.0.0.ro";
1957
1958         auto buf = _read_ro_file(pFirstRo);
1959
1960         int nRet = DTappsInstallLicense(reinterpret_cast<char *>(buf.data()));
1961
1962         if (nRet != TADC_SUCCESS) {
1963                 printf("tc13_DTappsInstallLicense_03() failed. nRet=%d\n", nRet);
1964                 return false;
1965         }
1966
1967         printf("tc13_DTappsInstallLicense_03() finished! -------- success \n");
1968         return true;
1969 }
1970
1971 bool
1972 tc_local_01_drm_tizen_generate_license_request_p(void)
1973 {
1974         bool res = true;
1975         int ret_value = DRMTEST_SUCCESS;
1976
1977         char *purchase_response = NULL;
1978         char *req_id = NULL;
1979         unsigned int  req_buff_len = 1024 * 5;
1980         char req_buff[req_buff_len] = {0, };
1981         unsigned int  url_buff_len = 1024;
1982         char url_buff[url_buff_len] = {0, };
1983
1984         printf("[%s] test started\n", __func__);
1985         ret_value = generate_purchase_response(&purchase_response, &req_id);
1986
1987         if (ret_value != DRMTEST_SUCCESS) {
1988                 res = false;
1989                 goto CATCH;
1990         }
1991
1992         printf("...purchase_response:\n%s\n", purchase_response);
1993
1994         ret_value = drm_tizen_generate_license_request(purchase_response,
1995                                 strlen(purchase_response),
1996                                 req_buff, &req_buff_len, url_buff, &url_buff_len);
1997
1998         if (ret_value != TADC_SUCCESS) {
1999                 printf("...drm_tizen_generate_license_request failed. ret=%d\n", ret_value);
2000                 res = false;
2001                 goto CATCH;
2002         }
2003
2004         printf("...license_request_url:%s\n", url_buff);
2005         printf("...license_request:\n%s\n", req_buff);
2006
2007         printf("[%s] test ended: result=%d\n", __func__, ret_value);
2008
2009 CATCH:
2010
2011         if (purchase_response != NULL)
2012                 free(purchase_response);
2013
2014         if (req_id != NULL)
2015                 free(req_id);
2016
2017         return res;
2018 }
2019
2020 bool
2021 tc_local_01_drm_tizen_full_test_p(void)
2022 {
2023         bool res = true;
2024         int ret_value = DRMTEST_SUCCESS;
2025
2026         char *purchase_response = NULL;
2027         char *req_id = NULL;
2028         unsigned int  req_buff_len = 1024 * 5;
2029         char req_buff[req_buff_len] = {0, };
2030         unsigned int  url_buff_len = 1024;
2031         char url_buff[url_buff_len] = {0, };
2032
2033         char *ro_request_buff = NULL;
2034         char *ro_response_buff = NULL;
2035         char *dh_key_p = NULL;
2036         char *dh_key_g = NULL;
2037         char *dh_key_a = NULL;
2038
2039         unsigned char duid[33] = {0, };
2040         const char *cid = "38EIfBurLJ-1.0.2";
2041         const char *ro_template_path = TEST_DATA_DIR "/RO/38EIfBurLJ-1.0.2.ro_template";
2042
2043         const char *encrypted_file_path = TEST_DATA_DIR "/DCF/38EIfBurLJ.tpk";
2044         const char *plaintext_file_path = TEST_DATA_DIR
2045                                                                           "/DecryptedApp/38EIfBurLJ_dec.tpk";
2046         const char *decrypted_file_path = "/tmp/38EIfBurLJ.tpk";
2047
2048         int identical = DRMTEST_NOTIDENTICAL;
2049
2050         printf("[%s] test started\n", __func__);
2051
2052         if (ret_value != DRMTEST_SUCCESS) {
2053                 res = false;
2054                 goto CATCH;
2055         }
2056
2057         ret_value = generate_purchase_response(&purchase_response, &req_id);
2058
2059         if (ret_value != DRMTEST_SUCCESS) {
2060                 res = false;
2061                 goto CATCH;
2062         }
2063
2064         //printf("...purchase_response:\n%s\n", purchase_response);
2065
2066         ret_value = drm_tizen_generate_license_request(purchase_response,
2067                                 strlen(purchase_response),
2068                                 req_buff, &req_buff_len, url_buff, &url_buff_len);
2069
2070         if (ret_value != TADC_SUCCESS) {
2071                 printf("...drm_tizen_generate_license_request failed. ret=%d\n", ret_value);
2072                 res = false;
2073                 goto CATCH;
2074         }
2075
2076         printf("...license_request_url:%s\n", url_buff);
2077         printf("...license_request:\n%s\n", req_buff);
2078
2079         ret_value = get_dh_key_from_ro_request(req_buff, &dh_key_p, &dh_key_g,
2080                                                                                    &dh_key_a);
2081
2082         if (ret_value != DRMTEST_SUCCESS) {
2083                 res = false;
2084                 goto CATCH;
2085         }
2086
2087         //printf("...DH key: p=%s, g=%s, a=%s\n", dh_key_p, dh_key_g, dh_key_a);
2088
2089         ret_value = TADC_IF_GetDUID((char *)duid);
2090
2091         if (ret_value != TADC_SUCCESS) {
2092                 return false;
2093         }
2094
2095         printf("duid=%s\n", (char *)duid);
2096
2097         ret_value = generate_right_object_response(dh_key_p, dh_key_g, dh_key_a, req_id,
2098                                 cid, ro_template_path, (const char *)duid, &ro_response_buff);
2099
2100         if (ret_value != DRMTEST_SUCCESS) {
2101                 res = false;
2102                 goto CATCH;
2103         }
2104
2105         printf("...right_object_response:\n%s\n", ro_response_buff);
2106
2107         ret_value = drm_tizen_register_license(ro_response_buff,
2108                                                                                    strlen(ro_response_buff));
2109
2110         if (ret_value != TADC_SUCCESS) {
2111                 printf("...drm_tizen_register_license failed. ret=%d\n", ret_value);
2112                 res = false;
2113                 goto CATCH;
2114         }
2115
2116         printf("...drm_tizen_register_license: succeeded\n");
2117
2118         ret_value = drm_tizen_decrypt_package(encrypted_file_path,
2119                                                                                   strlen(encrypted_file_path),
2120                                                                                   decrypted_file_path, strlen(decrypted_file_path));
2121
2122         if (ret_value != TADC_SUCCESS) {
2123                 printf("...drm_tizen_decrypt_package failed. ret=%d\n", ret_value);
2124                 res = false;
2125                 goto CATCH;
2126         }
2127
2128         printf("...drm_tizen_decrypt_package: succeeded\n");
2129
2130         ret_value = is_identical_files(plaintext_file_path, decrypted_file_path,
2131                                                                    &identical);
2132
2133         if (ret_value != DRMTEST_SUCCESS) {
2134                 printf("...is_identical_files failed. ret=%d\n", ret_value);
2135                 res = false;
2136                 goto CATCH;
2137         }
2138
2139         if (identical != DRMTEST_IDENTICAL) {
2140                 printf("...the decrypted file is not same with a original plaintext file .\n");
2141                 res = false;
2142                 goto CATCH;
2143         }
2144
2145         printf("...drm_tizen_decrypt_package: succeeded : the decrypted file is with a original plaintext file.\n");
2146
2147 CATCH:
2148
2149         if (purchase_response != NULL)
2150                 free(purchase_response);
2151
2152         if (req_id != NULL)
2153                 free(req_id);
2154
2155         if (ro_request_buff != NULL)
2156                 free(ro_request_buff);
2157
2158         if (ro_response_buff != NULL)
2159                 free(ro_response_buff);
2160
2161         return res;
2162 }
2163
2164
2165 /*
2166 bool tc15_DrmTdcDecryptPackge_01(void)
2167 {
2168     int nRet = TADC_SUCCESS;
2169
2170 }
2171 */
2172 #endif
2173
2174 int main(int, char *[])
2175 {
2176         printf(" ---------- Test Tizen DRM core --- Start ....\n");
2177         test_drm_core();
2178         printf(" ---------- Test Tizen DRM core ---  End  ....\n");
2179
2180 #if 1
2181         printf(" ---------- Test Tizen DRM v2.0.1 APIs   ---  Start ....    \n");
2182
2183         int bRet = TADC_SUCCESS;
2184
2185         char ReqBuf[1024 * 5] = {0, };
2186         unsigned int ReqBufLen = 0;
2187
2188         char RespBuf[1024 * 10] = {0, };
2189         unsigned int RespBufLen = 0;
2190
2191         //  char DecLicenseBuf[1024*10] = {0, };
2192         //  unsigned int DecLicenseBufLen = 0;
2193
2194         char LicenseUrl[1024] = {0, };
2195         unsigned int LicenseUrlLen = 0;
2196
2197         //2011.03.08
2198         //DrmTdcFileHeader TDCFileHeader;
2199         //  char cid[1024] = {0, };
2200         //  char riurl[1024] = {0, };
2201
2202         char testFileName[256] = {0, };
2203         char tempBuf[256] = {0, };
2204
2205         bool isOk = false;
2206
2207         //----------------------------------------------------------------------------------------------------
2208         // 0. Static TC running
2209         //----------------------------------------------------------------------------------------------------
2210
2211         printf("\n0. Static TC  Start  ----------------------------------------\n");
2212         /*
2213             isOk = tc01_VerifyRoSignature_Positive_01();
2214             if (isOk != true)
2215             {
2216                 printf("tc01_VerifyRoSignature_Positive_01 failed!\n");
2217             }
2218
2219             isOk = tc01_VerifyRoSignature_Positive_02();
2220             if (isOk != true)
2221             {
2222                 printf("tc01_VerifyRoSignature_Positive_02 failed!\n");
2223             }
2224
2225             isOk = tc01_VerifyRoSignature_Positive_03();
2226             if (isOk != true)
2227             {
2228                 printf("tc01_VerifyRoSignature_Positive_03 failed!\n");
2229             }
2230
2231             isOk = tc02_VerifyRoSignature_Negative_Cert_01();
2232             if (isOk != true)
2233             {
2234                 printf("tc02_VerifyRoSignature_Negative_Cert_01 failed!\n");
2235             }
2236
2237             isOk = tc02_VerifyRoSignature_Negative_Cert_02();
2238             if (isOk != true)
2239             {
2240                 printf("tc02_VerifyRoSignature_Negative_Cert_02 failed!\n");
2241             }
2242
2243             isOk = tc02_VerifyRoSignature_Negative_Cert_03();
2244             if (isOk != true)
2245             {
2246                 printf("tc02_VerifyRoSignature_Negative_Cert_03 failed!\n");
2247             }
2248
2249             isOk = tc03_VerifyRoSignature_Negative_Signature_01();
2250             if (isOk != true)
2251             {
2252                 printf("tc03_VerifyRoSignature_Negative_Signature_01 failed!\n");
2253             }
2254
2255             isOk = tc03_VerifyRoSignature_Negative_Signature_02();
2256             if (isOk != true)
2257             {
2258                 printf("tc03_VerifyRoSignature_Negative_Signature_02 failed!\n");
2259             }
2260
2261             isOk = tc03_VerifyRoSignature_Negative_Signature_03();
2262             if (isOk != true)
2263             {
2264                 printf("tc03_VerifyRoSignature_Negative_Signature_03 failed!\n");
2265             }
2266
2267             isOk = tc04_isDrmFile_Positive_01();
2268             if (isOk != true)
2269             {
2270                 printf("tc04_isDrmFile_Positive_01 failed!\n");
2271             }
2272
2273             isOk = tc04_isDrmFile_Positive_02();
2274             if (isOk != true)
2275             {
2276                 printf("tc04_isDrmFile_Positive_02 failed!\n");
2277             }
2278
2279             isOk = tc04_isDrmFile_Positive_03();
2280             if (isOk != true)
2281             {
2282                 printf("tc04_isDrmFile_Positive_03 failed!\n");
2283             }
2284
2285             isOk = tc05_isDrmFile_Negative_01();
2286             if (isOk != true)
2287             {
2288                 printf("tc05_isDrmFile_Negative_01 failed!\n");
2289             }
2290
2291             isOk = tc05_isDrmFile_Negative_02();
2292             if (isOk != true)
2293             {
2294                 printf("tc05_isDrmFile_Negative_02 failed!\n");
2295             }
2296
2297             isOk = tc05_isDrmFile_Negative_03();
2298             if (isOk != true)
2299             {
2300                 printf("tc05_isDrmFile_Negative_03 failed!\n");
2301             }
2302
2303             isOk = tc13_DTappsInstallLicense_01();
2304             if (isOk != true)
2305             {
2306                 printf("tc13_DTappsInstallLicense_01 failed!\n");
2307             }
2308
2309             isOk = tc13_DTappsInstallLicense_02();
2310             if (isOk != true)
2311             {
2312                 printf("tc13_DTappsInstallLicense_02 failed!\n");
2313             }
2314
2315             isOk = tc13_DTappsInstallLicense_03();
2316             if (isOk != true)
2317             {
2318                 printf("tc13_DTappsInstallLicense_03 failed!\n");
2319             }
2320
2321             isOk = tc06_DrmFileHandlerPositive_01();
2322             if (isOk != true)
2323             {
2324                 printf("tc06_DrmFileHandlerPositive_01 failed!\n");
2325             }
2326
2327             isOk = tc06_DrmFileHandlerPositive_02();
2328             if (isOk != true)
2329             {
2330                 printf("tc06_DrmFileHandlerPositive_02 failed!\n");
2331             }
2332
2333             isOk = tc06_DrmFileHandlerPositive_03();
2334             if (isOk != true)
2335             {
2336                 printf("tc06_DrmFileHandlerPositive_03 failed!\n");
2337             }
2338
2339             isOk = tc07_DrmFileMgrPositive_01();
2340             if (isOk != true)
2341             {
2342                 printf("tc07_DrmFileMgrPositive_01 failed!\b");
2343             }
2344
2345             isOk = tc07_DrmFileMgrPositive_02();
2346             if (isOk != true)
2347             {
2348                 printf("tc07_DrmFileMgrPositive_02 failed!\n");
2349             }
2350
2351             isOk = tc07_DrmFileMgrPositive_03();
2352             if (isOk != true)
2353             {
2354                 printf("tc07_DrmFileMgrPositive_03 failed!\n");
2355             }
2356
2357             isOk = tc08_DrmFileMgrPositive_GetFileHandler_01();
2358             if (isOk != true)
2359             {
2360                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 failed!\n");
2361             }
2362
2363             isOk = tc08_DrmFileMgrPositive_GetFileHandler_02();
2364             if (isOk != true)
2365             {
2366                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 failed!\n");
2367             }
2368
2369             isOk = tc08_DrmFileMgrPositive_GetFileHandler_03();
2370             if (isOk != true)
2371             {
2372                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 failed!\n");
2373             }
2374
2375             isOk = tc09_DrmFileMgrPositive_FileAPI_01();
2376             if (isOk != true)
2377             {
2378                 printf("tc09_DrmFileMgrPositive_FileAPI_01 failed!\n");
2379             }
2380
2381             isOk = tc09_DrmFileMgrPositive_FileAPI_02();
2382             if (isOk != true)
2383             {
2384                 printf("tc09_DrmFileMgrPositive_FileAPI_02 failed!\n");
2385             }
2386
2387             isOk = tc09_DrmFileMgrPositive_FileAPI_03();
2388             if (isOk != true)
2389             {
2390                 printf("tc09_DrmFileMgrPositive_FileAPI_03 failed!\n");
2391             }
2392
2393             isOk = tc10_DrmFileMgrPositive_CloseFileHandler_01();
2394             if (isOk != true)
2395             {
2396                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_01 failed!\n");
2397             }
2398
2399             isOk = tc10_DrmFileMgrPositive_CloseFileHandler_02();
2400             if (isOk != true)
2401             {
2402                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_02 failed!\n");
2403             }
2404
2405             isOk = tc10_DrmFileMgrPositive_CloseFileHandler_03();
2406             if (isOk != true)
2407             {
2408                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_03 failed!\n");
2409             }
2410
2411             isOk = tc11_GetDeviceId_01();
2412             if (isOk != true)
2413             {
2414                 printf("tc11_GetDeviceId_01 failed!\n");
2415             }
2416
2417             isOk = tc12_TADC_SetDeviceInfo_01();
2418             if (isOk != true)
2419             {
2420                 printf("tc12_TADC_SetDeviceInfo_01 failed!\n");
2421             }
2422
2423             isOk = tc11_GetDeviceId_01();
2424             if (isOk != true)
2425             {
2426                 printf("tc11_GetDeviceId_01 failed!\n");
2427             }
2428         */
2429         isOk = tc_local_01_drm_tizen_full_test_p();
2430
2431         if (isOk != true) {
2432                 printf("tc_local_01_drm_tizen_full_test_p failed!\n");
2433         }
2434
2435         //----------------------------------------------------------------------------------------------------
2436         // 1. Check is drm file
2437         //----------------------------------------------------------------------------------------------------
2438
2439         printf("===============================================================================\n");
2440         printf("Enter test file name  -->  ");
2441
2442         isOk = scanf("%s", testFileName);
2443
2444         if (isOk < 1) {
2445                 printf("Input value wrong! scanf() failed!!");
2446                 return 0;
2447         }
2448
2449         printf("\n1. drm_tizen_is_drm_file  Start  ----------------------------------------\n");
2450
2451         bRet = drm_tizen_is_drm_file(testFileName, strlen(testFileName));
2452
2453         if (bRet != TADC_SUCCESS) {
2454                 printf("drm_tizen_is_drm_file Error! ret = %d\n", bRet);
2455                 return 0;
2456         }
2457
2458         printf("%s file is TADC file!\n", testFileName);
2459
2460         //----------------------------------------------------------------------------------------------------
2461         // 2. Make PurchaseRequest Data
2462         //----------------------------------------------------------------------------------------------------
2463         printf("\n2. Make PurchaseRequest Data  Start  ----------------------------------------\n");
2464
2465         memset(ReqBuf, 0x00, sizeof(ReqBuf));
2466         memset(LicenseUrl, 0x00, sizeof(LicenseUrl));
2467         ReqBufLen = sizeof(ReqBuf);
2468         LicenseUrlLen = sizeof(LicenseUrl);
2469
2470         bRet = drm_tizen_generate_purchase_request(testFileName, ReqBuf, &ReqBufLen,
2471                         LicenseUrl, &LicenseUrlLen);
2472
2473         if (bRet == false) {
2474                 printf(" drm_tizen_generate_purchase_request Error!  \n");
2475                 return 0;
2476         }
2477
2478         printf("drm_tizen_generate_purchase_request - ReqBufLen : %d,  License Url : %s   \n",
2479                    ReqBufLen, LicenseUrl);
2480
2481         if ((bRet = _write_logfile("Request_1.dat", ReqBuf, ReqBufLen - 1)) == false) {
2482                 printf(" drm_tizen_generate_purchase_request _write_logfile Error!  \n");
2483                 return 0;
2484         }
2485
2486         //break.... HTTP Request & Reaponse Processing...
2487         printf("Enter any key after create Response_1.dat file. -->  ");
2488         std::cin >> tempBuf;
2489
2490         memset(RespBuf, 0x00, sizeof(RespBuf));
2491         RespBufLen = sizeof(RespBuf);
2492
2493         if ((bRet = _read_logfile("Response_1.dat", RespBuf, &RespBufLen)) == false) {
2494                 printf(" drm_tizen_generate_purchase_request _read_logfile Error!  \n");
2495                 return 0;
2496         }
2497
2498         //----------------------------------------------------------------------------------------------------
2499         // 3. Make License Request Data
2500         //----------------------------------------------------------------------------------------------------
2501         printf("\n3. Make License Request Data  Start  ----------------------------------------\n");
2502
2503         memset(ReqBuf, 0x00, sizeof(ReqBuf));
2504         memset(LicenseUrl, 0x00, sizeof(LicenseUrl));
2505         ReqBufLen = sizeof(ReqBuf);
2506         LicenseUrlLen = sizeof(LicenseUrl);
2507
2508         bRet = drm_tizen_generate_license_request(RespBuf,  RespBufLen, ReqBuf,
2509                         &ReqBufLen, LicenseUrl, &LicenseUrlLen);
2510
2511         if (bRet != TADC_SUCCESS) {
2512                 printf(" drm_tizen_generate_license_request Error!  \n");
2513                 return 0;
2514         }
2515
2516         printf("drm_tizen_generate_license_request - ReqBufLen : %d,  RO Url : %s   \n",
2517                    ReqBufLen, LicenseUrl);
2518
2519         if ((bRet = _write_logfile("Request_2.dat", ReqBuf, ReqBufLen - 1)) == false) {
2520                 printf(" drm_tizen_generate_license_request _write_logfile Error!  \n");
2521                 return 0;
2522         }
2523
2524         //break.... HTTP Request & Reaponse Processing...
2525         printf("Enter any key after create Response_2.dat file. -->  ");
2526         std::cin >> tempBuf;
2527
2528         memset(RespBuf, 0x00, sizeof(RespBuf));
2529         RespBufLen = sizeof(RespBuf);
2530
2531         if ((bRet = _read_logfile("Response_2.dat", RespBuf, &RespBufLen)) == false) {
2532                 printf(" drm_tizen_generate_license_request _read_logfile Error! \n");
2533                 return 0;
2534         }
2535
2536         //----------------------------------------------------------------------------------------------------
2537         // 4. Decrypt DRM License
2538         //----------------------------------------------------------------------------------------------------
2539         printf("\n4. Decrypt DRM License Start  --------------------------------------------\n");
2540
2541         bRet = drm_tizen_register_license(RespBuf, RespBufLen);
2542
2543         if (bRet != TADC_SUCCESS) {
2544                 printf(" drm_tizen_register_license  Error!  \n");
2545                 return 0;
2546         }
2547
2548         //---------------------------------------------------------------------------------------------------
2549         // 5. Decrypt DRM File
2550         //----------------------------------------------------------------------------------------------------
2551         printf("\n5. Decrypt DRM File Start  -----------------------------------------\n");
2552
2553         sprintf(tempBuf, "%s.dec", testFileName);
2554         bRet = drm_tizen_decrypt_package(testFileName, strlen(testFileName), tempBuf,
2555                                                                          strlen(tempBuf));
2556
2557         if (bRet != TADC_SUCCESS) {
2558                 printf(" drm_tizen_decrypt_package  Error!  \n");
2559                 return 0;
2560         }
2561
2562         printf("\n --------------Test Tizen Apps DRM APIs   ---  End ---------------\n");
2563
2564 #endif
2565 }