test/test_drm_trusted_client.cpp

   1 /*\r
   2  * drm-trusted client test utility\r
   3  *\r
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
   5  *\r
   6  * Contact: Hakjoo Ko <hakjoo.ko@samsung.com>\r
   7  *                      Mahendra Kumar Prajapat <mahendra.p@samsung.com>\r
   8  *                      Harsha Shekar <h.shekar@samsung.com>\r
   9  *\r
  10  *\r
  11  * Licensed under the Apache License, Version 2.0 (the "License");\r
  12  * you may not use this file except in compliance with the License.\r
  13  * You may obtain a copy of the License at\r
  14  *\r
  15  * http://www.apache.org/licenses/LICENSE-2.0\r
  16  *\r
  17  * Unless required by applicable law or agreed to in writing, software\r
  18  * distributed under the License is distributed on an "AS IS" BASIS,\r
  19  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  20  * See the License for the specific language governing permissions and\r
  21  * limitations under the License.\r
  22  *\r
  23  */\r
  24 \r
  25 /**\r
  26  * @file                test_drm_trusted_client.cpp\r
  27  * @brief       Test case implementation specific to DRM trusted Client APIs.\r
  28  * @author      Mahendra Kumar Prajapat (mahendra.p@samsung.com)\r
  29  * @author      Harsha Shekar (h.shekar@samsung.com)\r
  30  * @version     0.1\r
  31  * @history     0.1: First version of DRM trusted Client test utility.\r
  32  */\r
  33 \r
  34 #include <stdio.h>\r
  35 #include <string.h>\r
  36 #include <stdlib.h>\r
  37 #include <memory.h>\r
  38 #include <stdarg.h>\r
  39 #include <sys/time.h>\r
  40 #include <sys/types.h>\r
  41 #include <time.h>\r
  42 #include <fcntl.h>\r
  43 #include <sys/types.h>\r
  44 #include <sys/stat.h>\r
  45 #include <sys/syscall.h>\r
  46 #include <linux/unistd.h>\r
  47 #include <unistd.h>\r
  48 #include <dirent.h>\r
  49 #include <pthread.h>\r
  50 #include <assert.h>\r
  51 \r
  52 #include "drm_trusted_client.h"\r
  53 \r
  54 #define drm_trusted_client_tid() (long int)syscall(__NR_gettid)\r
  55 #define DRM_TRUSTED_CLIENT_TEST_FILENAME(X)   (strrchr((char*)(X), '/') ? (char*)(strrchr((char*)(X), '/') + 1) : ((char*)(X)) )\r
  56 \r
  57 #define DRM_TRUSTED_CLIENT_TEST_LOG(FMT, ARG...)        do{\\r
  58         fprintf(stderr,"[PID=%ld]:[TID=%ld]:[%s:%s:%d]:",(long int)getpid(),drm_trusted_client_tid(),DRM_TRUSTED_CLIENT_TEST_FILENAME(__FILE__),__func__,__LINE__);     \\r
  59         fprintf(stderr,FMT,##ARG); \\r
  60         fprintf(stderr,"\n"); \\r
  61         } while(0);\r
  62 \r
  63 #define DRM_TRUSTED_CLIENT_TEST_EXCEPTION(FMT, ARG...)  do{\\r
  64         fprintf(stderr,"[PID=%ld]:[TID=%ld]:[%s:%s:%d]:",(long int)getpid(),drm_trusted_client_tid(),DRM_TRUSTED_CLIENT_TEST_FILENAME(__FILE__),__func__,__LINE__);     \\r
  65         fprintf(stderr,"[ERROR]"FMT,##ARG); \\r
  66         fprintf(stderr,"\n"); \\r
  67         } while(0);\r
  68 \r
  69 static void drm_trusted_print_buffer(const char* info, unsigned char* buffer, unsigned int buflen)\r
  70 {\r
  71         DRM_TRUSTED_CLIENT_TEST_LOG("\n********* %s:buflen=%u buffer=%p ******** \n",info,buflen,buffer);\r
  72         DRM_TRUSTED_CLIENT_TEST_LOG("********* %s:Start******** \n",info);\r
  73         unsigned int i;\r
  74         for(i=1;i<=buflen;i++)\r
  75         {\r
  76                 fprintf(stderr,"0x%02X ",buffer[i-1]);\r
  77                 if((i%16 )==0) fprintf(stderr,"\n");\r
  78         }\r
  79         DRM_TRUSTED_CLIENT_TEST_LOG("********* %s:End  ******** \n",info);\r
  80 }\r
  81 \r
  82 enum {\r
  83         DRM_TRUSTED_CLIENT_TEST_NONE,\r
  84         DRM_TRUSTED_CLIENT_TEST_handle_request,\r
  85         DRM_TRUSTED_CLIENT_TEST_consume_content,\r
  86         DRM_TRUSTED_CLIENT_TEST_CONVERT,\r
  87         DRM_TRUSTED_CLIENT_TEST_MAX\r
  88 \r
  89 };\r
  90 \r
  91 void test_drm_trusted_operation_cb(drm_trusted_user_operation_info_s *operation_info,\r
  92                         void *output_data)\r
  93 {\r
  94         DRM_TRUSTED_CLIENT_TEST_LOG("Callback Hit:test_drm_trusted_operation_cb");\r
  95         DRM_TRUSTED_CLIENT_TEST_LOG("operation_status=%d",operation_info->operation_status);\r
  96         DRM_TRUSTED_CLIENT_TEST_LOG("operation_type=%d",operation_info->operation_type);\r
  97 }\r
  98 \r
  99 /* Statically allocate 10 MB\r
 100 1  KB = 1024  B\r
 101 1  MB = 1024 KB = 1024 * 1024\r
 102 10 MB = 10 * 1024 * 1024 B\r
 103 */\r
 104 //#define MAX_OUT_BUFFER_LEN (10 * 1024 * 1024)\r
 105 #define MAX_OUT_BUFFER_LEN (10 * 1024)\r
 106 \r
 107 \r
 108 void _handle_container_drm_content(DRM_DECRYPT_HANDLE pHandle,\r
 109                 drm_trusted_file_type_e file_type)\r
 110 {\r
 111         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p, file_type=%d",pHandle,file_type);\r
 112         drm_trusted_payload_info_s read_input_data;\r
 113         drm_trusted_read_decrypt_resp_data_s read_output_data;\r
 114         unsigned char out_file_path[256]={0};\r
 115         unsigned char *out_buffer = NULL;\r
 116         FILE *fp_out=NULL;\r
 117         int ret = -1;\r
 118         unsigned int written_size = 0;\r
 119 \r
 120         /* Allocate memory for Out Buffer */\r
 121         out_buffer = (unsigned char*)malloc(MAX_OUT_BUFFER_LEN);\r
 122         if (!out_buffer) {\r
 123                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("Memory Allocation Error!!!");\r
 124                 return;\r
 125         }\r
 126 \r
 127         memset(&read_input_data,0x0,sizeof(drm_trusted_payload_info_s));\r
 128         memset(&read_output_data,0x0,sizeof(drm_trusted_read_decrypt_resp_data_s));\r
 129 \r
 130         DRM_TRUSTED_CLIENT_TEST_LOG("Enter Output file name along with path where decrypted Data can be stored");\r
 131         scanf("%s",out_file_path);\r
 132         DRM_TRUSTED_CLIENT_TEST_LOG("Output decrypted file=%s",out_file_path);\r
 133 \r
 134         fp_out = fopen((const char*)out_file_path,"w+b");\r
 135         if(NULL == fp_out){\r
 136                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("fopen failed:error=%s",strerror(errno));\r
 137                 goto ErrorExit;\r
 138         }\r
 139 \r
 140         /* Actually exact plain text length should be used.\r
 141          * Plain text length can be obtained using drm_get_file_type */\r
 142         read_input_data.payload_data = out_buffer;\r
 143         read_input_data.payload_data_len = (unsigned int)MAX_OUT_BUFFER_LEN;\r
 144         ret = drm_trusted_read_decrypt_session(pHandle,&read_input_data,\r
 145                         &read_output_data);\r
 146         DRM_TRUSTED_CLIENT_TEST_LOG("ret = 0x%x Actual read_size=%u "\r
 147                         "Requested payload_data_len=%u",\r
 148                         ret,read_output_data.read_size,read_input_data.payload_data_len);\r
 149 \r
 150         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 151                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 152                                 "drm_trusted_read_decrypt_session Failed!!, ret=0x%x", ret);\r
 153         }\r
 154 \r
 155         if(read_output_data.read_size > 0){\r
 156                 written_size= fwrite(read_input_data.payload_data,1,\r
 157                                 read_output_data.read_size,fp_out);\r
 158                 DRM_TRUSTED_CLIENT_TEST_LOG("Actual written_size=%u "\r
 159                                         "Requested written size=%u",\r
 160                                         written_size,read_output_data.read_size);\r
 161         }\r
 162         fclose(fp_out);\r
 163 \r
 164         ErrorExit:\r
 165         if (out_buffer)\r
 166                 free(out_buffer);\r
 167 }\r
 168 \r
 169 void _handle_stream_drm_content(DRM_DECRYPT_HANDLE pHandle,\r
 170                 drm_trusted_file_type_e file_type)\r
 171 {\r
 172         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p, file_type=%d",pHandle,file_type);\r
 173 \r
 174         drm_trusted_payload_info_s read_input_data;\r
 175         drm_trusted_read_decrypt_resp_data_s read_output_data;\r
 176         int ret = -1;\r
 177 \r
 178         memset(&read_input_data,0x0,sizeof(drm_trusted_payload_info_s));\r
 179         memset(&read_output_data,0x0,sizeof(drm_trusted_read_decrypt_resp_data_s));\r
 180 \r
 181         switch(file_type)\r
 182         {\r
 183         case DRM_TRUSTED_TYPE_PLAYREADY:\r
 184         {\r
 185                 DRM_TRUSTED_CLIENT_TEST_LOG("PlayReady Content");\r
 186                 DRM_TRUSTED_CLIENT_TEST_LOG("Extract PayloadData,PayloadDataSize,ReplicatedData,ReplicatedDataSize & ObjectOffset From ASF parser application for EACH Payload");\r
 187                 DRM_TRUSTED_CLIENT_TEST_LOG("For testing purpose, currently it is hard-coded");\r
 188                 DRM_TRUSTED_CLIENT_TEST_LOG("These data are taken from 1st payload of jazz_AAC_V4AES.pya");\r
 189                 DRM_TRUSTED_CLIENT_TEST_LOG("As seen from corresponding clear file jazz_AAC.asf, Output decrypted buffer should be");\r
 190                 DRM_TRUSTED_CLIENT_TEST_LOG("0x20 0x00 0x20 0x00 0x00 0x80 0x0E");\r
 191                 unsigned char expected_output[] = {0x20, 0x00, 0x20, 0x00, 0x00, 0x80, 0x0E};\r
 192 \r
 193                 unsigned char PayloadData[] = {0xE5, 0x08, 0x6E, 0xAE, 0x61, 0xDF, 0x49};\r
 194                 unsigned int PayloadDataSize = sizeof(PayloadData) / sizeof(PayloadData[0]);\r
 195 \r
 196                 DRM_TRUSTED_CLIENT_TEST_LOG("Actual Replicated data is last 8 bytes of Replicated Data as seen from ASF viewer");\r
 197                 DRM_TRUSTED_CLIENT_TEST_LOG("Thus ReplicatedDataSize will be 8 bytes");\r
 198                 unsigned char ReplicatedData[] = {0x14, 0x45, 0x0F, 0x0A, 0x28, 0x15, 0xBF, 0x42};\r
 199                 unsigned int ReplicatedDataSize = sizeof(ReplicatedData) / sizeof(ReplicatedData[0]);\r
 200 \r
 201                 /* Start Decryption */\r
 202                 drm_trusted_print_buffer("Before:InputBuffer:",PayloadData,PayloadDataSize);\r
 203                 read_input_data.media_offset = 0;\r
 204                 read_input_data.payload_data = PayloadData;\r
 205                 read_input_data.payload_data_len = PayloadDataSize;\r
 206                 read_input_data.payload_iv = ReplicatedData;\r
 207                 read_input_data.payload_iv_len = ReplicatedDataSize;\r
 208 \r
 209                 ret = drm_trusted_read_decrypt_session(pHandle,&read_input_data,\r
 210                                 &read_output_data);\r
 211                 DRM_TRUSTED_CLIENT_TEST_LOG("ret = 0x%x Actual read_size=%u "\r
 212                                 "Requested payload_data_len=%u",\r
 213                                 ret,read_output_data.read_size,read_input_data.payload_data_len);\r
 214 \r
 215                 if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 216                         DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 217                                         "drm_trusted_read_decrypt_session Failed!!, ret=0x%x", ret);\r
 218                 }\r
 219                 drm_trusted_print_buffer("After:OutputBuffer:",read_input_data.payload_data,read_input_data.payload_data_len);\r
 220 \r
 221                 if(0 == memcmp(read_input_data.payload_data,expected_output,read_input_data.payload_data_len)){\r
 222                         DRM_TRUSTED_CLIENT_TEST_LOG("Decrypt is successful for jazz_AAC_V4AES.pya");\r
 223                 }\r
 224         }\r
 225         break;\r
 226 \r
 227         case DRM_TRUSTED_TYPE_DIVX:\r
 228         {\r
 229                 DRM_TRUSTED_CLIENT_TEST_LOG("DivX Content");\r
 230                 DRM_TRUSTED_CLIENT_TEST_LOG("Hard-coded testing is not available for DivX Content");\r
 231         }\r
 232         break;\r
 233 \r
 234         default:\r
 235                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 236                                 "Unknown file_type=%d",file_type);\r
 237 \r
 238         }\r
 239 }\r
 240 \r
 241 void _handle_read_data(DRM_DECRYPT_HANDLE pHandle,\r
 242                 drm_trusted_file_type_e file_type)\r
 243 {\r
 244         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p, file_type=%d",pHandle,file_type);\r
 245         switch(file_type)\r
 246         {\r
 247         case DRM_TRUSTED_TYPE_OMA_V1:\r
 248         case DRM_TRUSTED_TYPE_OMA_V2:\r
 249         case DRM_TRUSTED_TYPE_PLAYREADY_ENVELOPE:\r
 250                 DRM_TRUSTED_CLIENT_TEST_LOG("Container Based DRM file");\r
 251                 _handle_container_drm_content(pHandle,file_type);\r
 252                 break;\r
 253 \r
 254         case DRM_TRUSTED_TYPE_PLAYREADY:\r
 255         case DRM_TRUSTED_TYPE_DIVX:\r
 256                 DRM_TRUSTED_CLIENT_TEST_LOG("Stream Based DRM file");\r
 257                 _handle_stream_drm_content(pHandle,file_type);\r
 258                 break;\r
 259 \r
 260         default:\r
 261                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 262                                 "Unknown file_type=%d",file_type);\r
 263         }\r
 264 }\r
 265 \r
 266 void _render_drm_content(drm_trusted_file_type_e file_type)\r
 267 {\r
 268         /* Initialize variables & structures */\r
 269         drm_trusted_open_decrypt_info_s open_input_data;\r
 270         drm_trusted_open_decrypt_resp_data_s open_output_data;\r
 271         drm_trusted_seek_decrypt_info_s seek_input_data;\r
 272         drm_trusted_tell_decrypt_resp_data_s tell_output_data;\r
 273         drm_trusted_set_consumption_state_info_s state_input_data;\r
 274 \r
 275         DRM_DECRYPT_HANDLE pHandle = NULL;\r
 276         int ret = -1;\r
 277         drm_trusted_permission_type_e perm_type;\r
 278         char file_path[256]={0};\r
 279 \r
 280         DRM_TRUSTED_CLIENT_TEST_LOG("Enter DRM content name along with path");\r
 281         DRM_TRUSTED_CLIENT_TEST_LOG("Use jazz_AAC_V4AES.pya file if PlayReady decryption need to be tested");\r
 282         scanf("%s",file_path);\r
 283         DRM_TRUSTED_CLIENT_TEST_LOG("file_path received=%s",file_path);\r
 284 \r
 285         DRM_TRUSTED_CLIENT_TEST_LOG("Enter permission type");\r
 286         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_NONE",DRM_TRUSTED_PERMISSION_TYPE_NONE);\r
 287         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_ANY",DRM_TRUSTED_PERMISSION_TYPE_ANY);\r
 288         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_PLAY",DRM_TRUSTED_PERMISSION_TYPE_PLAY);\r
 289         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_COLLABORATIVE_PLAY",DRM_TRUSTED_PERMISSION_TYPE_COLLABORATIVE_PLAY);\r
 290         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_DISPLAY",DRM_TRUSTED_PERMISSION_TYPE_DISPLAY);\r
 291         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_EXECUTE",DRM_TRUSTED_PERMISSION_TYPE_EXECUTE);\r
 292         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_PRINT",DRM_TRUSTED_PERMISSION_TYPE_PRINT);\r
 293         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_EXPORT_COPY",DRM_TRUSTED_PERMISSION_TYPE_EXPORT_COPY);\r
 294         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_EXPORT_MOVE",DRM_TRUSTED_PERMISSION_TYPE_EXPORT_MOVE);\r
 295         scanf("%d", (int*)&perm_type);\r
 296         DRM_TRUSTED_CLIENT_TEST_LOG("perm_type = %d file_path=%s",perm_type,file_path);\r
 297 \r
 298         /* memset the structures */\r
 299         memset(&open_input_data,0x0,sizeof(drm_trusted_open_decrypt_info_s));\r
 300         memset(&open_output_data,0x0,sizeof(drm_trusted_open_decrypt_resp_data_s));\r
 301         memset(&seek_input_data,0x0,sizeof(     drm_trusted_seek_decrypt_info_s));\r
 302         memset(&tell_output_data,0x0,sizeof(drm_trusted_tell_decrypt_resp_data_s));\r
 303         memset(&state_input_data,0x0,sizeof(drm_trusted_set_consumption_state_info_s));\r
 304 \r
 305         /* Enter Appropriate Inputs */\r
 306         memcpy(open_input_data.filePath,file_path,strlen(file_path));\r
 307         open_input_data.file_type = file_type;\r
 308         open_input_data.permission = perm_type;\r
 309         open_input_data.operation_callback.callback = test_drm_trusted_operation_cb;\r
 310 \r
 311         /* Open Decrypt Session*/\r
 312         ret = drm_trusted_open_decrypt_session(&open_input_data,&open_output_data,\r
 313                         &pHandle);\r
 314         DRM_TRUSTED_CLIENT_TEST_LOG("ret = 0x%x",ret);\r
 315         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 316                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 317                                 "drm_trusted_open_decrypt_session Failed!!, ret=0x%x", ret);\r
 318                 return;\r
 319         }\r
 320         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p",pHandle);\r
 321         DRM_TRUSTED_CLIENT_TEST_LOG("result_code = 0x%x",open_output_data.result_code);\r
 322 \r
 323         /* Just for testing seek & tell APIs */\r
 324         seek_input_data.offset = 0;\r
 325         seek_input_data.seek_mode = DRM_SEEK_END; /* Set cursor to end */\r
 326         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p",pHandle);\r
 327         ret = drm_trusted_seek_decrypt_session(pHandle,&seek_input_data);\r
 328         DRM_TRUSTED_CLIENT_TEST_LOG("ret = 0x%x",ret);\r
 329         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 330                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 331                                 "drm_trusted_seek_decrypt_session Failed!!, ret=0x%x", ret);\r
 332         }\r
 333 \r
 334         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p",pHandle);\r
 335         ret = drm_trusted_tell_decrypt_session(pHandle,&tell_output_data);\r
 336         DRM_TRUSTED_CLIENT_TEST_LOG("ret = 0x%x",ret);\r
 337         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 338                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 339                                 "drm_trusted_tell_decrypt_session Failed!!, ret=0x%x", ret);\r
 340         }\r
 341         DRM_TRUSTED_CLIENT_TEST_LOG("file-size = %u",tell_output_data.offset);\r
 342 \r
 343         seek_input_data.offset = 0;\r
 344         seek_input_data.seek_mode = DRM_SEEK_SET; /* Again set cursor to beginning */\r
 345         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p",pHandle);\r
 346         ret = drm_trusted_seek_decrypt_session(pHandle,&seek_input_data);\r
 347         DRM_TRUSTED_CLIENT_TEST_LOG("ret = 0x%x",ret);\r
 348         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 349                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 350                                 "drm_trusted_seek_decrypt_session Failed!!, ret=0x%x", ret);\r
 351         }\r
 352 \r
 353         /* Before Read, Appropriate state MUST be SET */\r
 354         state_input_data.state = DRM_CONSUMPTION_STARTED;\r
 355         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p",pHandle);\r
 356         ret = drm_trusted_set_decrypt_state(pHandle,&state_input_data);\r
 357         DRM_TRUSTED_CLIENT_TEST_LOG("ret = 0x%x",ret);\r
 358         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 359                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 360                                 "drm_trusted_set_decrypt_state Failed!!, ret=0x%x", ret);\r
 361                 goto Err;\r
 362         }\r
 363 \r
 364         /* Handle READ / DECRYPT operation */\r
 365         _handle_read_data(pHandle,file_type);\r
 366 \r
 367         /* When rendering is stopped */\r
 368         state_input_data.state = DRM_CONSUMPTION_STOPPED;\r
 369         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p",pHandle);\r
 370         ret = drm_trusted_set_decrypt_state(pHandle,&state_input_data);\r
 371         DRM_TRUSTED_CLIENT_TEST_LOG("ret = 0x%x",ret);\r
 372         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 373                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 374                                 "drm_trusted_set_decrypt_state Failed!!, ret=0x%x", ret);\r
 375                 goto Err;\r
 376         }\r
 377 \r
 378         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p",pHandle);\r
 379         ret = drm_trusted_close_decrypt_session(&pHandle);\r
 380         DRM_TRUSTED_CLIENT_TEST_LOG("ret = 0x%x",ret);\r
 381         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 382                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 383                                 "drm_trusted_close_decrypt_session Failed!!, ret=0x%x", ret);\r
 384                 return;\r
 385         }\r
 386         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p",pHandle);\r
 387 \r
 388         DRM_TRUSTED_CLIENT_TEST_LOG("SUCCESS");\r
 389         return;\r
 390 \r
 391 Err:\r
 392         DRM_TRUSTED_CLIENT_TEST_EXCEPTION("Failed, ret=0x%x", ret);\r
 393         drm_trusted_close_decrypt_session(&pHandle);\r
 394 }\r
 395 \r
 396 void _render_drm_oma_progressive_download_content(void)\r
 397 {\r
 398         DRM_TRUSTED_CLIENT_TEST_LOG("Progressive Download scenario");\r
 399         DRM_TRUSTED_CLIENT_TEST_LOG("Hard-coded testing is not available for Progressive Download scenario");\r
 400 }\r
 401 \r
 402 void _render_drm_piff_content(void)\r
 403 {\r
 404         /* Initialize variables & structures */\r
 405         drm_trusted_open_decrypt_info_s open_input_data;\r
 406         drm_trusted_open_decrypt_resp_data_s open_output_data;\r
 407         drm_trusted_set_consumption_state_info_s state_input_data;\r
 408 \r
 409         drm_trusted_payload_info_s read_input_data;\r
 410         drm_trusted_read_decrypt_resp_data_s read_output_data;\r
 411 \r
 412         memset(&read_input_data,0x0,sizeof(drm_trusted_payload_info_s));\r
 413         memset(&read_output_data,0x0,sizeof(drm_trusted_read_decrypt_resp_data_s));\r
 414 \r
 415         DRM_DECRYPT_HANDLE pHandle = NULL;\r
 416         int ret = -1;\r
 417         drm_trusted_permission_type_e perm_type;\r
 418 \r
 419         DRM_TRUSTED_CLIENT_TEST_LOG("Enter permission type");\r
 420         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_NONE",DRM_TRUSTED_PERMISSION_TYPE_NONE);\r
 421         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_ANY",DRM_TRUSTED_PERMISSION_TYPE_ANY);\r
 422         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_PLAY",DRM_TRUSTED_PERMISSION_TYPE_PLAY);\r
 423         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_COLLABORATIVE_PLAY",DRM_TRUSTED_PERMISSION_TYPE_COLLABORATIVE_PLAY);\r
 424         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_DISPLAY",DRM_TRUSTED_PERMISSION_TYPE_DISPLAY);\r
 425         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_EXECUTE",DRM_TRUSTED_PERMISSION_TYPE_EXECUTE);\r
 426         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_PRINT",DRM_TRUSTED_PERMISSION_TYPE_PRINT);\r
 427         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_EXPORT_COPY",DRM_TRUSTED_PERMISSION_TYPE_EXPORT_COPY);\r
 428         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_PERMISSION_TYPE_EXPORT_MOVE",DRM_TRUSTED_PERMISSION_TYPE_EXPORT_MOVE);\r
 429         scanf("%d", (int*)&perm_type);\r
 430         DRM_TRUSTED_CLIENT_TEST_LOG("perm_type = %d",perm_type);\r
 431 \r
 432         DRM_TRUSTED_CLIENT_TEST_LOG("Sample Content => SuperSpeedway_720_230.ismv");\r
 433 \r
 434         /* Content Header        <.W.R.M.H.E.A.D.E.R. .x.m.l.n.s.=.".h.t.t.p.:././.s.c.h.e.m.a.s...m.i.c.r.o.s.o.f.t...c.o.m./.D.R.M./.2.0.0.7./.0.3./.P.l.a.y.R.e.a.d.y.H.e.a.d.e.r.". .v.e.r.s.i.o.n.=.".4...0...0...0.".>.\r
 435          *                                       <.D.A.T.A.>.\r
 436          *                                       <.P.R.O.T.E.C.T.I.N.F.O.>.\r
 437          *                                       <.K.E.Y.L.E.N.>.1.6.<./.K.E.Y.L.E.N.>.\r
 438          *                                       <.A.L.G.I.D.>.A.E.S.C.T.R.<./.A.L.G.I.D.>.\r
 439          *                                       <./.P.R.O.T.E.C.T.I.N.F.O.>.\r
 440          *                                       <.K.I.D.>.A.m.f.j.C.T.O.P.b.E.O.l.3.W.D./.5.m.c.e.c.A.=.=.<./.K.I.D.>.\r
 441          *                                       <.C.H.E.C.K.S.U.M.>.B.G.w.1.a.Y.Z.1.Y.X.M.=.<./.C.H.E.C.K.S.U.M.>.\r
 442          *                                       <.C.U.S.T.O.M.A.T.T.R.I.B.U.T.E.S.>.\r
 443          *                                       <.I.I.S._.D.R.M._.V.E.R.S.I.O.N.>.7...1...1.0.6.4...0.<./.I.I.S._.D.R.M._.V.E.R.S.I.O.N.>.\r
 444          *                                       <./.C.U.S.T.O.M.A.T.T.R.I.B.U.T.E.S.>.\r
 445          *                                       <.L.A._.U.R.L.>.h.t.t.p.:././.p.l.a.y.r.e.a.d.y...d.i.r.e.c.t.t.a.p.s...n.e.t./.p.r./.s.v.c./.r.i.g.h.t.s.m.a.n.a.g.e.r...a.s.m.x.<./.L.A._.U.R.L.>.\r
 446          *                                       <.D.S._.I.D.>.A.H.+.0.3.j.u.K.b.U.G.b.H.l.1.V./.Q.I.w.R.A.=.=.<./.D.S._.I.D.>.\r
 447          *                                       <./.D.A.T.A.>.\r
 448          *                                       <./.W.R.M.H.E.A.D.E.R.>... */\r
 449 \r
 450         unsigned char ContentHeader[] ={0x3C,0x00,0x57,0x00,0x52,0x00,0x4D,0x00,0x48,0x00,0x45,0x00,0x41,0x00,0x44,0x00,0x45,0x00,0x52,0x00,0x20,0x00,0x78,0x00,0x6D,0x00,0x6C,0x00,0x6E,0x00,\r
 451                                                                         0x73,0x00,0x3D,0x00,0x22,0x00,0x68,0x00,0x74,0x00,0x74,0x00,0x70,0x00,0x3A,0x00,0x2F,0x00,0x2F,0x00,0x73,0x00,0x63,0x00,0x68,0x00,0x65,0x00,0x6D,0x00,\r
 452                                                                         0x61,0x00,0x73,0x00,0x2E,0x00,0x6D,0x00,0x69,0x00,0x63,0x00,0x72,0x00,0x6F,0x00,0x73,0x00,0x6F,0x00,0x66,0x00,0x74,0x00,0x2E,0x00,0x63,0x00,0x6F,0x00,\r
 453                                                                         0x6D,0x00,0x2F,0x00,0x44,0x00,0x52,0x00,0x4D,0x00,0x2F,0x00,0x32,0x00,0x30,0x00,0x30,0x00,0x37,0x00,0x2F,0x00,0x30,0x00,0x33,0x00,0x2F,0x00,0x50,0x00,\r
 454                                                                         0x6C,0x00,0x61,0x00,0x79,0x00,0x52,0x00,0x65,0x00,0x61,0x00,0x64,0x00,0x79,0x00,0x48,0x00,0x65,0x00,0x61,0x00,0x64,0x00,0x65,0x00,0x72,0x00,0x22,0x00,\r
 455                                                                         0x20,0x00,0x76,0x00,0x65,0x00,0x72,0x00,0x73,0x00,0x69,0x00,0x6F,0x00,0x6E,0x00,0x3D,0x00,0x22,0x00,0x34,0x00,0x2E,0x00,0x30,0x00,0x2E,0x00,0x30,0x00,\r
 456                                                                         0x2E,0x00,0x30,0x00,0x22,0x00,0x3E,0x00,0x3C,0x00,0x44,0x00,0x41,0x00,0x54,0x00,0x41,0x00,0x3E,0x00,0x3C,0x00,0x50,0x00,0x52,0x00,0x4F,0x00,0x54,0x00,\r
 457                                                                         0x45,0x00,0x43,0x00,0x54,0x00,0x49,0x00,0x4E,0x00,0x46,0x00,0x4F,0x00,0x3E,0x00,0x3C,0x00,0x4B,0x00,0x45,0x00,0x59,0x00,0x4C,0x00,0x45,0x00,0x4E,0x00,\r
 458                                                                         0x3E,0x00,0x31,0x00,0x36,0x00,0x3C,0x00,0x2F,0x00,0x4B,0x00,0x45,0x00,0x59,0x00,0x4C,0x00,0x45,0x00,0x4E,0x00,0x3E,0x00,0x3C,0x00,0x41,0x00,0x4C,0x00,\r
 459                                                                         0x47,0x00,0x49,0x00,0x44,0x00,0x3E,0x00,0x41,0x00,0x45,0x00,0x53,0x00,0x43,0x00,0x54,0x00,0x52,0x00,0x3C,0x00,0x2F,0x00,0x41,0x00,0x4C,0x00,0x47,0x00,\r
 460                                                                         0x49,0x00,0x44,0x00,0x3E,0x00,0x3C,0x00,0x2F,0x00,0x50,0x00,0x52,0x00,0x4F,0x00,0x54,0x00,0x45,0x00,0x43,0x00,0x54,0x00,0x49,0x00,0x4E,0x00,0x46,0x00,\r
 461                                                                         0x4F,0x00,0x3E,0x00,0x3C,0x00,0x4B,0x00,0x49,0x00,0x44,0x00,0x3E,0x00,0x41,0x00,0x6D,0x00,0x66,0x00,0x6A,0x00,0x43,0x00,0x54,0x00,0x4F,0x00,0x50,0x00,\r
 462                                                                         0x62,0x00,0x45,0x00,0x4F,0x00,0x6C,0x00,0x33,0x00,0x57,0x00,0x44,0x00,0x2F,0x00,0x35,0x00,0x6D,0x00,0x63,0x00,0x65,0x00,0x63,0x00,0x41,0x00,0x3D,0x00,\r
 463                                                                         0x3D,0x00,0x3C,0x00,0x2F,0x00,0x4B,0x00,0x49,0x00,0x44,0x00,0x3E,0x00,0x3C,0x00,0x43,0x00,0x48,0x00,0x45,0x00,0x43,0x00,0x4B,0x00,0x53,0x00,0x55,0x00,\r
 464                                                                         0x4D,0x00,0x3E,0x00,0x42,0x00,0x47,0x00,0x77,0x00,0x31,0x00,0x61,0x00,0x59,0x00,0x5A,0x00,0x31,0x00,0x59,0x00,0x58,0x00,0x4D,0x00,0x3D,0x00,0x3C,0x00,\r
 465                                                                         0x2F,0x00,0x43,0x00,0x48,0x00,0x45,0x00,0x43,0x00,0x4B,0x00,0x53,0x00,0x55,0x00,0x4D,0x00,0x3E,0x00,0x3C,0x00,0x43,0x00,0x55,0x00,0x53,0x00,0x54,0x00,\r
 466                                                                         0x4F,0x00,0x4D,0x00,0x41,0x00,0x54,0x00,0x54,0x00,0x52,0x00,0x49,0x00,0x42,0x00,0x55,0x00,0x54,0x00,0x45,0x00,0x53,0x00,0x3E,0x00,0x3C,0x00,0x49,0x00,\r
 467                                                                         0x49,0x00,0x53,0x00,0x5F,0x00,0x44,0x00,0x52,0x00,0x4D,0x00,0x5F,0x00,0x56,0x00,0x45,0x00,0x52,0x00,0x53,0x00,0x49,0x00,0x4F,0x00,0x4E,0x00,0x3E,0x00,\r
 468                                                                         0x37,0x00,0x2E,0x00,0x31,0x00,0x2E,0x00,0x31,0x00,0x30,0x00,0x36,0x00,0x34,0x00,0x2E,0x00,0x30,0x00,0x3C,0x00,0x2F,0x00,0x49,0x00,0x49,0x00,0x53,0x00,\r
 469                                                                         0x5F,0x00,0x44,0x00,0x52,0x00,0x4D,0x00,0x5F,0x00,0x56,0x00,0x45,0x00,0x52,0x00,0x53,0x00,0x49,0x00,0x4F,0x00,0x4E,0x00,0x3E,0x00,0x3C,0x00,0x2F,0x00,\r
 470                                                                         0x43,0x00,0x55,0x00,0x53,0x00,0x54,0x00,0x4F,0x00,0x4D,0x00,0x41,0x00,0x54,0x00,0x54,0x00,0x52,0x00,0x49,0x00,0x42,0x00,0x55,0x00,0x54,0x00,0x45,0x00,\r
 471                                                                         0x53,0x00,0x3E,0x00,0x3C,0x00,0x4C,0x00,0x41,0x00,0x5F,0x00,0x55,0x00,0x52,0x00,0x4C,0x00,0x3E,0x00,0x68,0x00,0x74,0x00,0x74,0x00,0x70,0x00,0x3A,0x00,\r
 472                                                                         0x2F,0x00,0x2F,0x00,0x70,0x00,0x6C,0x00,0x61,0x00,0x79,0x00,0x72,0x00,0x65,0x00,0x61,0x00,0x64,0x00,0x79,0x00,0x2E,0x00,0x64,0x00,0x69,0x00,0x72,0x00,\r
 473                                                                         0x65,0x00,0x63,0x00,0x74,0x00,0x74,0x00,0x61,0x00,0x70,0x00,0x73,0x00,0x2E,0x00,0x6E,0x00,0x65,0x00,0x74,0x00,0x2F,0x00,0x70,0x00,0x72,0x00,0x2F,0x00,\r
 474                                                                         0x73,0x00,0x76,0x00,0x63,0x00,0x2F,0x00,0x72,0x00,0x69,0x00,0x67,0x00,0x68,0x00,0x74,0x00,0x73,0x00,0x6D,0x00,0x61,0x00,0x6E,0x00,0x61,0x00,0x67,0x00,\r
 475                                                                         0x65,0x00,0x72,0x00,0x2E,0x00,0x61,0x00,0x73,0x00,0x6D,0x00,0x78,0x00,0x3C,0x00,0x2F,0x00,0x4C,0x00,0x41,0x00,0x5F,0x00,0x55,0x00,0x52,0x00,0x4C,0x00,\r
 476                                                                         0x3E,0x00,0x3C,0x00,0x44,0x00,0x53,0x00,0x5F,0x00,0x49,0x00,0x44,0x00,0x3E,0x00,0x41,0x00,0x48,0x00,0x2B,0x00,0x30,0x00,0x33,0x00,0x6A,0x00,0x75,0x00,\r
 477                                                                         0x4B,0x00,0x62,0x00,0x55,0x00,0x47,0x00,0x62,0x00,0x48,0x00,0x6C,0x00,0x31,0x00,0x56,0x00,0x2F,0x00,0x51,0x00,0x49,0x00,0x77,0x00,0x52,0x00,0x41,0x00,\r
 478                                                                         0x3D,0x00,0x3D,0x00,0x3C,0x00,0x2F,0x00,0x44,0x00,0x53,0x00,0x5F,0x00,0x49,0x00,0x44,0x00,0x3E,0x00,0x3C,0x00,0x2F,0x00,0x44,0x00,0x41,0x00,0x54,0x00,\r
 479                                                                         0x41,0x00,0x3E,0x00,0x3C,0x00,0x2F,0x00,0x57,0x00,0x52,0x00,0x4D,0x00,0x48,0x00,0x45,0x00,0x41,0x00,0x44,0x00,0x45,0x00,0x52,0x00,0x3E,0x00,0x00,0x00};\r
 480 \r
 481         /* Enter Appropriate Inputs */\r
 482         open_input_data.file_type = DRM_TRUSTED_TYPE_PIFF;\r
 483         open_input_data.permission = perm_type;\r
 484         open_input_data.operation_callback.callback = test_drm_trusted_operation_cb;\r
 485         open_input_data.lic_header.header = ContentHeader;\r
 486         open_input_data.lic_header.header_len = sizeof(ContentHeader);\r
 487 \r
 488         /* Open Decrypt Session*/\r
 489         ret = drm_trusted_open_decrypt_session(&open_input_data,&open_output_data,\r
 490                         &pHandle);\r
 491         DRM_TRUSTED_CLIENT_TEST_LOG("ret = 0x%x",ret);\r
 492         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 493                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 494                                 "drm_trusted_open_decrypt_session Failed!!, ret=0x%x", ret);\r
 495                 return;\r
 496         }\r
 497         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p",pHandle);\r
 498         DRM_TRUSTED_CLIENT_TEST_LOG("result_code = 0x%x",open_output_data.result_code);\r
 499 \r
 500         DRM_TRUSTED_CLIENT_TEST_LOG("Extract Payload and IV information and pass it through PIFF payload info");\r
 501         DRM_TRUSTED_CLIENT_TEST_LOG("Sample Payload - Encrypted");\r
 502         DRM_TRUSTED_CLIENT_TEST_LOG("0xE8,0xC6,0xF8,0x49,0xF3,0x0E,0x52,0xFB,0xC5,0xFA,0xF1");\r
 503         DRM_TRUSTED_CLIENT_TEST_LOG("Corresponding Decrypted Payload");\r
 504         DRM_TRUSTED_CLIENT_TEST_LOG("0x88,0x80,0x40,0x01,0x71,0xA3,0x7F,0xD9,0xEF,0xA7,0xF2");\r
 505         DRM_TRUSTED_CLIENT_TEST_LOG("Sample IV");\r
 506         DRM_TRUSTED_CLIENT_TEST_LOG("0xF4,0xB3,0x10,0x77,0x75,0x3F,0x69,0x94");\r
 507 \r
 508         unsigned char PayLoadData[] =     {0xE8,0xC6,0xF8,0x49,0xF3,0x0E,0x52,0xFB,0xC5,0xFA,0xF1};\r
 509         unsigned char InitVect[] =        {0xF4,0xB3,0x10,0x77,0x75,0x3F,0x69,0x94};\r
 510         unsigned char expected_output[] = {0x88,0x80,0x40,0x01,0x71,0xA3,0x7F,0xD9,0xEF,0xA7,0xF2};\r
 511 \r
 512         /* Before Read, Appropriate state MUST be SET */\r
 513         state_input_data.state = DRM_CONSUMPTION_STARTED;\r
 514         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p",pHandle);\r
 515         ret = drm_trusted_set_decrypt_state(pHandle,&state_input_data);\r
 516         DRM_TRUSTED_CLIENT_TEST_LOG("ret = 0x%x",ret);\r
 517         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 518                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 519                                 "drm_trusted_set_decrypt_state Failed!!, ret=0x%x", ret);\r
 520                 goto Err;\r
 521         }\r
 522 \r
 523         /* Start Decryption */\r
 524         read_input_data.media_offset = 0;\r
 525         read_input_data.payload_data = PayLoadData;\r
 526         read_input_data.payload_data_len = sizeof(PayLoadData)/sizeof(PayLoadData[0]);\r
 527         read_input_data.payload_iv = InitVect;\r
 528         read_input_data.payload_iv_len = sizeof(InitVect)/sizeof(InitVect[0]);\r
 529         drm_trusted_print_buffer("Before:InputBuffer:",read_input_data.payload_data,read_input_data.payload_data_len);\r
 530 \r
 531         ret = drm_trusted_read_decrypt_session(pHandle,&read_input_data,\r
 532                         &read_output_data);\r
 533         DRM_TRUSTED_CLIENT_TEST_LOG("ret = 0x%x Actual read_size=%u "\r
 534                         "Requested payload_data_len=%u",\r
 535                         ret,read_output_data.read_size,read_input_data.payload_data_len);\r
 536 \r
 537         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 538                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 539                                 "drm_trusted_read_decrypt_session Failed!!, ret=0x%x", ret);\r
 540         }\r
 541         drm_trusted_print_buffer("After:OutputBuffer:",read_input_data.payload_data,read_input_data.payload_data_len);\r
 542 \r
 543         if(0 == memcmp(read_input_data.payload_data,expected_output,read_input_data.payload_data_len)){\r
 544                 DRM_TRUSTED_CLIENT_TEST_LOG("Decrypt is successful for SuperSpeedway_720_230.ismv");\r
 545         }\r
 546 \r
 547         /* When rendering is stopped */\r
 548         state_input_data.state = DRM_CONSUMPTION_STOPPED;\r
 549         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p",pHandle);\r
 550         ret = drm_trusted_set_decrypt_state(pHandle,&state_input_data);\r
 551         DRM_TRUSTED_CLIENT_TEST_LOG("ret = 0x%x",ret);\r
 552         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 553                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 554                                 "drm_trusted_set_decrypt_state Failed!!, ret=0x%x", ret);\r
 555                 goto Err;\r
 556         }\r
 557 \r
 558         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p",pHandle);\r
 559         ret = drm_trusted_close_decrypt_session(&pHandle);\r
 560         DRM_TRUSTED_CLIENT_TEST_LOG("ret = 0x%x",ret);\r
 561         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 562                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 563                                 "drm_trusted_close_decrypt_session Failed!!, ret=0x%x", ret);\r
 564                 return;\r
 565         }\r
 566         DRM_TRUSTED_CLIENT_TEST_LOG("pHandle = %p",pHandle);\r
 567 \r
 568         DRM_TRUSTED_CLIENT_TEST_LOG("SUCCESS");\r
 569         return;\r
 570 \r
 571 Err:\r
 572         DRM_TRUSTED_CLIENT_TEST_EXCEPTION("Failed, ret=0x%x", ret);\r
 573         drm_trusted_close_decrypt_session(&pHandle);\r
 574 }\r
 575 \r
 576 \r
 577 void test_consume_content(void)\r
 578 {\r
 579         DRM_TRUSTED_CLIENT_TEST_LOG("Start");\r
 580         drm_trusted_file_type_e file_type = DRM_TRUSTED_TYPE_UNDEFINED;\r
 581 \r
 582         /* Enter simulation information */\r
 583         DRM_TRUSTED_CLIENT_TEST_LOG("Enter the file_type");\r
 584         DRM_TRUSTED_CLIENT_TEST_LOG("Application can know file_type by calling"\r
 585                         "drm_get_file_type");\r
 586         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TYPE_OMA_V1 \n",DRM_TRUSTED_TYPE_OMA_V1);\r
 587         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TYPE_OMA_V2 \n",DRM_TRUSTED_TYPE_OMA_V2);\r
 588         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TYPE_PLAYREADY \n",DRM_TRUSTED_TYPE_PLAYREADY);\r
 589         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TYPE_PLAYREADY_ENVELOPE \n",DRM_TRUSTED_TYPE_PLAYREADY_ENVELOPE);\r
 590         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TYPE_DIVX \n",DRM_TRUSTED_TYPE_DIVX);\r
 591 \r
 592         DRM_TRUSTED_CLIENT_TEST_LOG("Application can know about OMA DRM Progressive download"\r
 593          "when browser download OMA DD (Download descriptor)"\r
 594          "In DD, there is field progressiveDownloadFlag"\r
 595          "if progressiveDownloadFlag = true it means"\r
 596          "the content MUST be rendering in progressive download mode.");\r
 597          DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TYPE_OMA_PD \n",DRM_TRUSTED_TYPE_OMA_PD);\r
 598 \r
 599         DRM_TRUSTED_CLIENT_TEST_LOG("Application can know about PIFF / Smooth Streaming"\r
 600                         "when browser download Manifest file");\r
 601         DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TYPE_PIFF \n",DRM_TRUSTED_TYPE_PIFF);\r
 602 \r
 603         scanf("%d", (int*)&file_type);\r
 604         DRM_TRUSTED_CLIENT_TEST_LOG("file_type received=%d",file_type);\r
 605 \r
 606         switch(file_type){\r
 607         case DRM_TRUSTED_TYPE_OMA_V1:\r
 608         case DRM_TRUSTED_TYPE_OMA_V2:\r
 609         case DRM_TRUSTED_TYPE_PLAYREADY:\r
 610         case DRM_TRUSTED_TYPE_PLAYREADY_ENVELOPE:\r
 611         case DRM_TRUSTED_TYPE_DIVX:\r
 612                 DRM_TRUSTED_CLIENT_TEST_LOG("Handle file based rendering");\r
 613                 _render_drm_content(file_type);\r
 614                 break;\r
 615 \r
 616         case DRM_TRUSTED_TYPE_OMA_PD:\r
 617                 DRM_TRUSTED_CLIENT_TEST_LOG("Handle OMA DRM Progressive download rendering");\r
 618                 _render_drm_oma_progressive_download_content();\r
 619                 break;\r
 620 \r
 621         case DRM_TRUSTED_TYPE_PIFF:\r
 622                 DRM_TRUSTED_CLIENT_TEST_LOG("Handle OMA DRM Progressive download rendering");\r
 623                 _render_drm_piff_content();\r
 624                 break;\r
 625 \r
 626         default:\r
 627                 DRM_TRUSTED_CLIENT_TEST_LOG("UnKnown file_type=%d",file_type);\r
 628                 return;\r
 629         }\r
 630 \r
 631         DRM_TRUSTED_CLIENT_TEST_LOG("Completed");\r
 632 }\r
 633 \r
 634 void test_convert(char* SourceDMfilePath, char* DestDCFfilepath)\r
 635 {\r
 636         DRM_TRUSTED_CONVERT_HANDLE hConvert;\r
 637         drm_trusted_opn_conv_info_s input;\r
 638         drm_trusted_write_conv_info_s write_input;\r
 639         drm_trusted_write_conv_resp_s output;\r
 640 \r
 641         FILE *fp = NULL;\r
 642         int FileSize=0;\r
 643         unsigned char *buffer = NULL;\r
 644         struct stat statbuf;\r
 645         int readed_size = 0;\r
 646         int ret = -1;\r
 647 \r
 648         /* memset the structures */\r
 649         memset(&hConvert, 0x0, sizeof(DRM_TRUSTED_CONVERT_HANDLE));\r
 650         memset(&input, 0x0, sizeof(drm_trusted_opn_conv_info_s));\r
 651         memset(&output, 0x0, sizeof(drm_trusted_write_conv_resp_s));\r
 652         memset(&write_input, 0x0, sizeof(drm_trusted_opn_conv_info_s));\r
 653         memset(&statbuf, 0x0, sizeof(struct stat));\r
 654 \r
 655         memcpy(input.filePath,DestDCFfilepath,strlen(DestDCFfilepath));\r
 656 \r
 657         input.install_RO = DRM_TRUSTED_FALSE;\r
 658 \r
 659         ret = drm_trusted_open_convert(&input,&hConvert);\r
 660 \r
 661         DRM_TRUSTED_CLIENT_TEST_LOG("drm_trusted_open_convert:ret=0x%x",ret);\r
 662         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 663                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 664                 "drm_trusted_open_convert Failed!!, ret=0x%x", ret);\r
 665             return;\r
 666         }\r
 667 \r
 668         fp = fopen(SourceDMfilePath, "r");\r
 669         if (fp == NULL){\r
 670                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("fopen error:error=%s",strerror(errno));\r
 671             goto err;\r
 672         }\r
 673 \r
 674         if(stat(SourceDMfilePath, &statbuf) == 0 ){\r
 675             FileSize = (unsigned int)statbuf.st_size;\r
 676         }else{\r
 677                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("stat failed:error = %s",strerror(errno));\r
 678                 goto err;\r
 679         }\r
 680         DRM_TRUSTED_CLIENT_TEST_LOG("FileSize=%d",FileSize);\r
 681 \r
 682         if(0 == FileSize){\r
 683                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("%s is empty",SourceDMfilePath);\r
 684             goto err;\r
 685         }\r
 686 \r
 687         buffer = (unsigned char *)malloc(FileSize + 1);\r
 688         if(!buffer){\r
 689                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("malloc failed:error=%s",strerror(errno));\r
 690             goto err;\r
 691         }\r
 692         memset(buffer, 0x0, FileSize+1);\r
 693         readed_size = fread(buffer,1,FileSize,fp);\r
 694         DRM_TRUSTED_CLIENT_TEST_LOG("read_size=%d FileSize=%d",readed_size,FileSize);\r
 695         if(ferror(fp)){\r
 696                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("fread failed:error=%s",strerror(errno));\r
 697                 goto err;\r
 698         }\r
 699 \r
 700         buffer[FileSize] = '\0';\r
 701         write_input.data_len = readed_size;\r
 702         write_input.data = buffer;\r
 703 \r
 704         DRM_TRUSTED_CLIENT_TEST_LOG("data_len=%d",write_input.data_len);\r
 705 \r
 706         ret = drm_trusted_write_convert(&write_input,&output,hConvert);\r
 707 \r
 708         DRM_TRUSTED_CLIENT_TEST_LOG("drm_trusted_write_convert:ret=0x%x",ret);\r
 709         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 710                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 711                 "drm_trusted_write_convert Failed!!, ret=0x%x", ret);\r
 712             goto err;\r
 713         }\r
 714 \r
 715         DRM_TRUSTED_CLIENT_TEST_LOG("bytes written=%u filesize=%d",output.write_size,FileSize);\r
 716         if((unsigned int)FileSize != output.write_size){\r
 717                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("Data is not written successfully");\r
 718                 goto err;\r
 719         }\r
 720 \r
 721         ret = drm_trusted_close_convert(&hConvert);\r
 722         DRM_TRUSTED_CLIENT_TEST_LOG("drm_trusted_close_convert:ret = 0x%x",ret);\r
 723         if(DRM_TRUSTED_RETURN_SUCCESS != ret){\r
 724                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 725                 "drm_trusted_close_convert Failed!!, ret=0x%x", ret);\r
 726                 hConvert = NULL;\r
 727                 goto err;\r
 728         }\r
 729 \r
 730     fclose(fp);\r
 731     free(buffer);\r
 732         DRM_TRUSTED_CLIENT_TEST_LOG("SUCCESS");\r
 733         return;\r
 734 \r
 735 err:\r
 736         DRM_TRUSTED_CLIENT_TEST_EXCEPTION("Failed");\r
 737         if(hConvert) drm_trusted_close_convert(&hConvert);\r
 738         if(fp) fclose(fp);\r
 739         if(buffer) free(buffer);\r
 740         return;\r
 741 }\r
 742 \r
 743 int test_case(int option)\r
 744 {\r
 745         char filePath[300] = {0,};\r
 746         char distfilePath[300] = {0,};\r
 747 \r
 748         DRM_TRUSTED_CLIENT_TEST_LOG("option=[%d]", option);\r
 749 \r
 750         switch (option) {\r
 751         case DRM_TRUSTED_CLIENT_TEST_NONE:\r
 752         {\r
 753                 DRM_TRUSTED_CLIENT_TEST_LOG("DRM_TRUSTED_CLIENT_TEST_NONE start");\r
 754                 DRM_TRUSTED_CLIENT_TEST_LOG("DRM_TRUSTED_CLIENT_TEST_NONE completed");\r
 755                 break;\r
 756         }\r
 757 \r
 758         case DRM_TRUSTED_CLIENT_TEST_handle_request:\r
 759         {\r
 760                 DRM_TRUSTED_CLIENT_TEST_LOG("DRM_TRUSTED_CLIENT_TEST_handle_request start");\r
 761                 drm_trusted_request_type_e request_type = DRM_TRUSTED_REQ_TYPE_NONE;\r
 762 \r
 763                 DRM_TRUSTED_CLIENT_TEST_LOG("Enter the request type to be processed");\r
 764                 DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_REQ_TYPE_UPDATE_SECURE_CLK",DRM_TRUSTED_REQ_TYPE_UPDATE_SECURE_CLK);\r
 765                 DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_REQ_TYPE_SET_SECURE_CLK",DRM_TRUSTED_REQ_TYPE_SET_SECURE_CLK);\r
 766                 DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_REQ_TYPE_SET_TRANSACTION_TRACKING",DRM_TRUSTED_REQ_TYPE_SET_TRANSACTION_TRACKING);\r
 767                 DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_REQ_TYPE_MASTER_RESET",DRM_TRUSTED_REQ_TYPE_MASTER_RESET);\r
 768                 DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_REQ_TYPE_VERIFY_ENCRYPTED_CERT",DRM_TRUSTED_REQ_TYPE_VERIFY_ENCRYPTED_CERT);\r
 769                 DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_REQ_TYPE_CREATE_INIT_DB",DRM_TRUSTED_REQ_TYPE_CREATE_INIT_DB);\r
 770                 DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_REQ_TYPE_REINSTALL_CERT",DRM_TRUSTED_REQ_TYPE_REINSTALL_CERT);\r
 771                 DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_REQ_TYPE_REMOVE_RO",DRM_TRUSTED_REQ_TYPE_REMOVE_RO);\r
 772                 DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_REQ_TYPE_REMOVE_ALL_RO",DRM_TRUSTED_REQ_TYPE_REMOVE_ALL_RO);\r
 773                 DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_REQ_TYPE_GO_RIGHTS_URL",DRM_TRUSTED_REQ_TYPE_GO_RIGHTS_URL);\r
 774                 DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_REQ_TYPE_PD_SET_DOWNLOAD_COMPLETE",DRM_TRUSTED_REQ_TYPE_PD_SET_DOWNLOAD_COMPLETE);\r
 775                 DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_REQ_TYPE_PD_GET_PARSE_STATUS_INFO",DRM_TRUSTED_REQ_TYPE_PD_GET_PARSE_STATUS_INFO);\r
 776                 DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_REQ_TYPE_PIFF_GET_LICENSE",DRM_TRUSTED_REQ_TYPE_PIFF_GET_LICENSE);\r
 777                 DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_REQ_TYPE_SAPPS_DECRYPT_PACKAGE",DRM_TRUSTED_REQ_TYPE_SAPPS_DECRYPT_PACKAGE);\r
 778                 DRM_TRUSTED_CLIENT_TEST_LOG(" %d ==> DRM_TRUSTED_REQ_TYPE_SAPPS_CONSUME_LICENSE",DRM_TRUSTED_REQ_TYPE_SAPPS_CONSUME_LICENSE);\r
 779                 scanf("%d", (int*)&request_type);\r
 780                 DRM_TRUSTED_CLIENT_TEST_LOG("request_type received=%d",request_type);\r
 781 \r
 782                 switch(request_type) {\r
 783 \r
 784                 case DRM_TRUSTED_REQ_TYPE_UPDATE_SECURE_CLK:\r
 785                 {\r
 786                         struct tm* tmst = NULL;\r
 787                         long int delta = 0, newtime = 0, oldtime = 0;\r
 788                         int ret = -1;\r
 789                         drm_trusted_update_sec_clk_info_s upd_clk_info = { 0, };\r
 790 \r
 791                         DRM_TRUSTED_CLIENT_TEST_LOG("Enter delta sec \n");\r
 792                         scanf("%ld",&delta);\r
 793                         DRM_TRUSTED_CLIENT_TEST_LOG("delta = %ld \n",delta);\r
 794 \r
 795                         oldtime = (long int)time(NULL);\r
 796                         DRM_TRUSTED_CLIENT_TEST_LOG("Old Local Time = %ld = %s \n",oldtime,ctime(&oldtime));\r
 797 \r
 798                         newtime = oldtime + delta;\r
 799                         tmst = localtime(&newtime);\r
 800                         DRM_TRUSTED_CLIENT_TEST_LOG("New Local Time = %ld = %s \n",newtime,asctime(tmst));\r
 801 \r
 802                         upd_clk_info.before = oldtime;\r
 803                         upd_clk_info.after = newtime;\r
 804 \r
 805                         ret = drm_trusted_handle_request(request_type,\r
 806                                         (void *) &upd_clk_info, NULL);\r
 807                         DRM_TRUSTED_CLIENT_TEST_LOG("ret=0x%x", ret);\r
 808 \r
 809                         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
 810                                 DRM_TRUSTED_CLIENT_TEST_LOG("Update Secure Clock Success!!");\r
 811                         } else {\r
 812                                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 813                                                 "Update Secure Clock Failed!!, ret=0x%x", ret);\r
 814                         }\r
 815 \r
 816                         break;\r
 817                 }\r
 818 \r
 819                 case DRM_TRUSTED_REQ_TYPE_SET_SECURE_CLK:\r
 820                 {\r
 821                         DRM_TRUSTED_CLIENT_TEST_LOG("Set Secure Clock!!");\r
 822                         struct tm* tmst = NULL;\r
 823                         long int delta = 0, locatime = 0, securetime = 0;\r
 824                         int ret = -1;\r
 825                         drm_trusted_set_sec_clk_info_s sec_clk_info;\r
 826                         memset(&sec_clk_info, 0x00, sizeof(drm_trusted_set_sec_clk_info_s));\r
 827 \r
 828                         DRM_TRUSTED_CLIENT_TEST_LOG("Enter delta sec \n");\r
 829                         scanf("%ld",&delta);\r
 830                         DRM_TRUSTED_CLIENT_TEST_LOG("delta = %ld \n",delta);\r
 831 \r
 832                         locatime = (long int)time(NULL);\r
 833                         DRM_TRUSTED_CLIENT_TEST_LOG("Current Local Time = %ld = %s \n",locatime,ctime(&locatime));\r
 834 \r
 835                         securetime = locatime + delta;\r
 836                         tmst = localtime(&securetime);\r
 837                         DRM_TRUSTED_CLIENT_TEST_LOG("Current Secure Time = %ld = %s \n",\r
 838                                         securetime, asctime(tmst));\r
 839 \r
 840                         memcpy(&sec_clk_info.secure_time, tmst, sizeof(struct tm));\r
 841                         sec_clk_info.source_type = DRM_TRUSTED_TS_NITZ;\r
 842 \r
 843                         ret = drm_trusted_handle_request(request_type,\r
 844                                         (void *) &sec_clk_info, NULL);\r
 845                         DRM_TRUSTED_CLIENT_TEST_LOG("ret=0x%x", ret);\r
 846 \r
 847                         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
 848                                 DRM_TRUSTED_CLIENT_TEST_LOG("Set Secure Clock Success!!");\r
 849                         } else {\r
 850                                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 851                                                 "Set Secure Clock Failed!!, ret=0x%x", ret);\r
 852                         }\r
 853                         break;\r
 854 \r
 855                         break;\r
 856                 }\r
 857 \r
 858                 case DRM_TRUSTED_REQ_TYPE_SET_TRANSACTION_TRACKING:\r
 859                 {\r
 860                         int ret = -1;\r
 861                         drm_trusted_set_transaction_trk_info_s trk_info;\r
 862                         int value = 0;\r
 863 \r
 864                         memset(&trk_info, 0x00, sizeof(drm_trusted_set_transaction_trk_info_s));\r
 865 \r
 866                         DRM_TRUSTED_CLIENT_TEST_LOG("Enter 1 for tracking ON and 0 for OFF");\r
 867                         scanf("%d", &value);\r
 868 \r
 869                         if (1 == value) {\r
 870                                 trk_info.tracking_on = DRM_TRUSTED_TRUE;\r
 871                         } else if (0 == value) {\r
 872                                 trk_info.tracking_on = DRM_TRUSTED_FALSE;\r
 873                         } else {\r
 874                                 trk_info.tracking_on = DRM_TRUSTED_UNKNOWN;\r
 875                         }\r
 876 \r
 877                         ret = drm_trusted_handle_request(request_type,\r
 878                                         (void *) &trk_info, NULL);\r
 879                         DRM_TRUSTED_CLIENT_TEST_LOG("ret=0x%x", ret);\r
 880 \r
 881                         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
 882                                 DRM_TRUSTED_CLIENT_TEST_LOG("Set Transaction Tracking Success!!");\r
 883                         } else {\r
 884                                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION(\r
 885                                                 "Set Transaction Tracking Failed!!, ret=0x%x", ret);\r
 886                         }\r
 887                         break;\r
 888                 }\r
 889 \r
 890                 case DRM_TRUSTED_REQ_TYPE_MASTER_RESET:\r
 891                 {\r
 892                         int ret = -1;\r
 893                         DRM_TRUSTED_CLIENT_TEST_LOG("DRM_TRUSTED_REQ_TYPE_MASTER_RESET");\r
 894                         ret = drm_trusted_handle_request(request_type,NULL,NULL);\r
 895                         DRM_TRUSTED_CLIENT_TEST_LOG("ret=0x%x",ret);\r
 896                         if(DRM_TRUSTED_RETURN_SUCCESS == ret){\r
 897                                 DRM_TRUSTED_CLIENT_TEST_LOG("MASTER RESET Success");\r
 898                         }else{\r
 899                                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("MASTER RESET FAILED: ret=0x%x", ret);\r
 900                         }\r
 901                 }\r
 902                 break;\r
 903 \r
 904                 case DRM_TRUSTED_REQ_TYPE_VERIFY_ENCRYPTED_CERT:\r
 905                 {\r
 906                         int ret = -1;\r
 907                         DRM_TRUSTED_CLIENT_TEST_LOG("DRM_TRUSTED_REQ_TYPE_VERIFY_ENCRYPTED_CERT");\r
 908                         ret = drm_trusted_handle_request(request_type,NULL,NULL);\r
 909                         DRM_TRUSTED_CLIENT_TEST_LOG("ret=0x%x",ret);\r
 910 \r
 911                         if(DRM_TRUSTED_RETURN_SUCCESS == ret){\r
 912                                 DRM_TRUSTED_CLIENT_TEST_LOG("verifying encrypted certificate Success");\r
 913                         }else{\r
 914                                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("verifying encrypted certificate FAILED: ret=0x%x", ret);\r
 915                         }\r
 916                         break;\r
 917                 }\r
 918 \r
 919                 case DRM_TRUSTED_REQ_TYPE_CREATE_INIT_DB:\r
 920                 {\r
 921                         int ret = -1;\r
 922                         DRM_TRUSTED_CLIENT_TEST_LOG("DRM_TRUSTED_REQ_TYPE_CREATE_INIT_DB");\r
 923                         ret = drm_trusted_handle_request(request_type,NULL,NULL);\r
 924                         DRM_TRUSTED_CLIENT_TEST_LOG("ret=0x%x",ret);\r
 925                         if(DRM_TRUSTED_RETURN_SUCCESS == ret){\r
 926                                 DRM_TRUSTED_CLIENT_TEST_LOG("CREATE_INIT_DB Success");\r
 927                         }else{\r
 928                                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("CREATE_INIT_DB FAILED: ret=0x%x", ret);\r
 929                         }\r
 930                         break;\r
 931                 }\r
 932 \r
 933                 case DRM_TRUSTED_REQ_TYPE_REINSTALL_CERT:\r
 934                 {\r
 935                         int ret = -1;\r
 936                         DRM_TRUSTED_CLIENT_TEST_LOG("DRM_TRUSTED_REQ_TYPE_REINSTALL_CERT");\r
 937                         ret = drm_trusted_handle_request(request_type,NULL,NULL);\r
 938                         DRM_TRUSTED_CLIENT_TEST_LOG("ret=0x%x",ret);\r
 939                         if(DRM_TRUSTED_RETURN_SUCCESS == ret){\r
 940                                 DRM_TRUSTED_CLIENT_TEST_LOG("REINSTALL_CERT Success");\r
 941                         }else{\r
 942                                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("REINSTALL_CERT FAILED: ret=0x%x", ret);\r
 943                         }\r
 944                         break;\r
 945                 }\r
 946 \r
 947                 case DRM_TRUSTED_REQ_TYPE_REMOVE_RO:\r
 948                 {\r
 949                         int ret = -1;\r
 950                         DRM_TRUSTED_CLIENT_TEST_LOG("DRM_TRUSTED_REQ_TYPE_REMOVE_RO");\r
 951                         drm_trusted_remove_ro_info_s remove_ro_info;\r
 952                         memset(&remove_ro_info, 0x00, sizeof(drm_trusted_remove_ro_info_s));\r
 953 \r
 954                         DRM_TRUSTED_CLIENT_TEST_LOG("Enter the file path");\r
 955                         scanf("%s",remove_ro_info.filePath);\r
 956                         DRM_TRUSTED_CLIENT_TEST_LOG("file path=%s",remove_ro_info.filePath);\r
 957                         ret = drm_trusted_handle_request(request_type,(void *)&remove_ro_info, NULL);\r
 958                         DRM_TRUSTED_CLIENT_TEST_LOG("ret=0x%x", ret);\r
 959                         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
 960                         DRM_TRUSTED_CLIENT_TEST_LOG("REMOVE_RO Success!!");\r
 961                         } else {\r
 962                                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("REMOVE_RO Failed!!, ret=0x%x", ret);\r
 963                         }\r
 964                         break;\r
 965                 }\r
 966 \r
 967                 case DRM_TRUSTED_REQ_TYPE_REMOVE_ALL_RO:\r
 968                 {\r
 969                         int ret = -1;\r
 970                         DRM_TRUSTED_CLIENT_TEST_LOG("DRM_TRUSTED_REQ_TYPE_REMOVE_ALL_RO");\r
 971 \r
 972                         ret = drm_trusted_handle_request(request_type,NULL,NULL);\r
 973                         DRM_TRUSTED_CLIENT_TEST_LOG("ret=0x%x",ret);\r
 974                         if(DRM_TRUSTED_RETURN_SUCCESS == ret){\r
 975                                 DRM_TRUSTED_CLIENT_TEST_LOG("REMOVE_ALL_RO Success");\r
 976                         }else{\r
 977                                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("REMOVE_ALL_RO FAILED: ret=0x%x", ret);\r
 978                         }\r
 979                         break;\r
 980                 }\r
 981 \r
 982                 case DRM_TRUSTED_REQ_TYPE_GO_RIGHTS_URL:\r
 983                 {\r
 984                         int ret = -1;\r
 985                         drm_trusted_go_rights_url_info_s rights_url_info;\r
 986                         memset(&rights_url_info, 0x00, sizeof(drm_trusted_go_rights_url_info_s));\r
 987 \r
 988                         DRM_TRUSTED_CLIENT_TEST_LOG("Enter the file path");\r
 989                         scanf("%s",rights_url_info.file_path);\r
 990 \r
 991                         DRM_TRUSTED_CLIENT_TEST_LOG("Enter=%d => DRM_ROURL_METHOD_ROPAYLOAD",DRM_ROURL_METHOD_ROPAYLOAD);\r
 992                         DRM_TRUSTED_CLIENT_TEST_LOG("Enter=%d => DRM_ROURL_METHOD_SILENT",DRM_ROURL_METHOD_SILENT);\r
 993                         DRM_TRUSTED_CLIENT_TEST_LOG("Enter the RO URL Type");\r
 994                         scanf("%d",(int*)&(rights_url_info.rourl_type));\r
 995 \r
 996                         DRM_TRUSTED_CLIENT_TEST_LOG("file_path=%s rourl_type=%d",rights_url_info.file_path,rights_url_info.rourl_type);\r
 997                         ret = drm_trusted_handle_request(request_type,(void *)&rights_url_info, NULL);\r
 998                         DRM_TRUSTED_CLIENT_TEST_LOG("ret=0x%x", ret);\r
 999                         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
1000                         DRM_TRUSTED_CLIENT_TEST_LOG("GO_RIGHTS_URL Success!!");\r
1001                         } else {\r
1002                                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("GO_RIGHTS_URL Failed!!, ret=0x%x", ret);\r
1003                         }\r
1004                         break;\r
1005                 }\r
1006 \r
1007                 case DRM_TRUSTED_REQ_TYPE_PD_SET_DOWNLOAD_COMPLETE:\r
1008                 {\r
1009                         int ret = -1;\r
1010                         drm_trusted_pd_set_dld_comp_info_s download_cmp_info;\r
1011                         memset(&download_cmp_info, 0x00, sizeof(drm_trusted_pd_set_dld_comp_info_s));\r
1012 \r
1013                         ret = drm_trusted_handle_request(request_type,(void *)&download_cmp_info, NULL);\r
1014                         DRM_TRUSTED_CLIENT_TEST_LOG("ret=0x%x", ret);\r
1015                         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
1016                         DRM_TRUSTED_CLIENT_TEST_LOG("PD_SET_DOWNLOAD_COMPLETE Success!!");\r
1017                         } else {\r
1018                                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("PD_SET_DOWNLOAD_COMPLETE Failed!!, ret=0x%x", ret);\r
1019                         }\r
1020                         break;\r
1021                 }\r
1022 \r
1023                 case DRM_TRUSTED_REQ_TYPE_PD_GET_PARSE_STATUS_INFO:\r
1024                 {\r
1025                         int ret = -1;\r
1026                         drm_trusted_pd_parse_status_info_s info_status;\r
1027                         drm_trusted_pd_parse_status_resp_s resp_status;\r
1028                         memset(&info_status, 0x00, sizeof(drm_trusted_pd_parse_status_info_s));\r
1029                         memset(&resp_status, 0x00, sizeof(drm_trusted_pd_parse_status_resp_s));\r
1030 \r
1031                         DRM_TRUSTED_CLIENT_TEST_LOG("Enter the file path");\r
1032                         scanf("%s",info_status.file_path);\r
1033                         DRM_TRUSTED_CLIENT_TEST_LOG("file_path=%s",info_status.file_path);\r
1034 \r
1035                         ret = drm_trusted_handle_request(request_type,(void *)&info_status, (void *)&resp_status);\r
1036                         DRM_TRUSTED_CLIENT_TEST_LOG("ret=0x%x", ret);\r
1037                         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
1038                         DRM_TRUSTED_CLIENT_TEST_LOG("PD_GET_PARSE_STATUS_INFO Success!!");\r
1039                         } else {\r
1040                                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("PD_GET_PARSE_STATUS_INFO Failed!!, ret=0x%x", ret);\r
1041                         }\r
1042                         break;\r
1043                 }\r
1044 \r
1045                 case DRM_TRUSTED_REQ_TYPE_PIFF_GET_LICENSE:\r
1046                 {\r
1047                         int ret = -1;\r
1048                         drm_trusted_piff_get_license_info_s license_info;\r
1049 \r
1050                         /* Sample Content => SuperSpeedway_720_230.ismv */\r
1051 \r
1052                         /* Content Header        <.W.R.M.H.E.A.D.E.R. .x.m.l.n.s.=.".h.t.t.p.:././.s.c.h.e.m.a.s...m.i.c.r.o.s.o.f.t...c.o.m./.D.R.M./.2.0.0.7./.0.3./.P.l.a.y.R.e.a.d.y.H.e.a.d.e.r.". .v.e.r.s.i.o.n.=.".4...0...0...0.".>.\r
1053                          *                                       <.D.A.T.A.>.\r
1054                          *                                       <.P.R.O.T.E.C.T.I.N.F.O.>.\r
1055                          *                                       <.K.E.Y.L.E.N.>.1.6.<./.K.E.Y.L.E.N.>.\r
1056                          *                                       <.A.L.G.I.D.>.A.E.S.C.T.R.<./.A.L.G.I.D.>.\r
1057                          *                                       <./.P.R.O.T.E.C.T.I.N.F.O.>.\r
1058                          *                                       <.K.I.D.>.A.m.f.j.C.T.O.P.b.E.O.l.3.W.D./.5.m.c.e.c.A.=.=.<./.K.I.D.>.\r
1059                          *                                       <.C.H.E.C.K.S.U.M.>.B.G.w.1.a.Y.Z.1.Y.X.M.=.<./.C.H.E.C.K.S.U.M.>.\r
1060                          *                                       <.C.U.S.T.O.M.A.T.T.R.I.B.U.T.E.S.>.\r
1061                          *                                       <.I.I.S._.D.R.M._.V.E.R.S.I.O.N.>.7...1...1.0.6.4...0.<./.I.I.S._.D.R.M._.V.E.R.S.I.O.N.>.\r
1062                          *                                       <./.C.U.S.T.O.M.A.T.T.R.I.B.U.T.E.S.>.\r
1063                          *                                       <.L.A._.U.R.L.>.h.t.t.p.:././.p.l.a.y.r.e.a.d.y...d.i.r.e.c.t.t.a.p.s...n.e.t./.p.r./.s.v.c./.r.i.g.h.t.s.m.a.n.a.g.e.r...a.s.m.x.<./.L.A._.U.R.L.>.\r
1064                          *                                       <.D.S._.I.D.>.A.H.+.0.3.j.u.K.b.U.G.b.H.l.1.V./.Q.I.w.R.A.=.=.<./.D.S._.I.D.>.\r
1065                          *                                       <./.D.A.T.A.>.\r
1066                          *                                       <./.W.R.M.H.E.A.D.E.R.>... */\r
1067 \r
1068                         unsigned char ContentHeader[] ={0x3C,0x00,0x57,0x00,0x52,0x00,0x4D,0x00,0x48,0x00,0x45,0x00,0x41,0x00,0x44,0x00,0x45,0x00,0x52,0x00,0x20,0x00,0x78,0x00,0x6D,0x00,0x6C,0x00,0x6E,0x00,\r
1069                                         0x73,0x00,0x3D,0x00,0x22,0x00,0x68,0x00,0x74,0x00,0x74,0x00,0x70,0x00,0x3A,0x00,0x2F,0x00,0x2F,0x00,0x73,0x00,0x63,0x00,0x68,0x00,0x65,0x00,0x6D,0x00,\r
1070                                         0x61,0x00,0x73,0x00,0x2E,0x00,0x6D,0x00,0x69,0x00,0x63,0x00,0x72,0x00,0x6F,0x00,0x73,0x00,0x6F,0x00,0x66,0x00,0x74,0x00,0x2E,0x00,0x63,0x00,0x6F,0x00,\r
1071                                         0x6D,0x00,0x2F,0x00,0x44,0x00,0x52,0x00,0x4D,0x00,0x2F,0x00,0x32,0x00,0x30,0x00,0x30,0x00,0x37,0x00,0x2F,0x00,0x30,0x00,0x33,0x00,0x2F,0x00,0x50,0x00,\r
1072                                         0x6C,0x00,0x61,0x00,0x79,0x00,0x52,0x00,0x65,0x00,0x61,0x00,0x64,0x00,0x79,0x00,0x48,0x00,0x65,0x00,0x61,0x00,0x64,0x00,0x65,0x00,0x72,0x00,0x22,0x00,\r
1073                                         0x20,0x00,0x76,0x00,0x65,0x00,0x72,0x00,0x73,0x00,0x69,0x00,0x6F,0x00,0x6E,0x00,0x3D,0x00,0x22,0x00,0x34,0x00,0x2E,0x00,0x30,0x00,0x2E,0x00,0x30,0x00,\r
1074                                         0x2E,0x00,0x30,0x00,0x22,0x00,0x3E,0x00,0x3C,0x00,0x44,0x00,0x41,0x00,0x54,0x00,0x41,0x00,0x3E,0x00,0x3C,0x00,0x50,0x00,0x52,0x00,0x4F,0x00,0x54,0x00,\r
1075                                         0x45,0x00,0x43,0x00,0x54,0x00,0x49,0x00,0x4E,0x00,0x46,0x00,0x4F,0x00,0x3E,0x00,0x3C,0x00,0x4B,0x00,0x45,0x00,0x59,0x00,0x4C,0x00,0x45,0x00,0x4E,0x00,\r
1076                                         0x3E,0x00,0x31,0x00,0x36,0x00,0x3C,0x00,0x2F,0x00,0x4B,0x00,0x45,0x00,0x59,0x00,0x4C,0x00,0x45,0x00,0x4E,0x00,0x3E,0x00,0x3C,0x00,0x41,0x00,0x4C,0x00,\r
1077                                         0x47,0x00,0x49,0x00,0x44,0x00,0x3E,0x00,0x41,0x00,0x45,0x00,0x53,0x00,0x43,0x00,0x54,0x00,0x52,0x00,0x3C,0x00,0x2F,0x00,0x41,0x00,0x4C,0x00,0x47,0x00,\r
1078                                         0x49,0x00,0x44,0x00,0x3E,0x00,0x3C,0x00,0x2F,0x00,0x50,0x00,0x52,0x00,0x4F,0x00,0x54,0x00,0x45,0x00,0x43,0x00,0x54,0x00,0x49,0x00,0x4E,0x00,0x46,0x00,\r
1079                                         0x4F,0x00,0x3E,0x00,0x3C,0x00,0x4B,0x00,0x49,0x00,0x44,0x00,0x3E,0x00,0x41,0x00,0x6D,0x00,0x66,0x00,0x6A,0x00,0x43,0x00,0x54,0x00,0x4F,0x00,0x50,0x00,\r
1080                                         0x62,0x00,0x45,0x00,0x4F,0x00,0x6C,0x00,0x33,0x00,0x57,0x00,0x44,0x00,0x2F,0x00,0x35,0x00,0x6D,0x00,0x63,0x00,0x65,0x00,0x63,0x00,0x41,0x00,0x3D,0x00,\r
1081                                         0x3D,0x00,0x3C,0x00,0x2F,0x00,0x4B,0x00,0x49,0x00,0x44,0x00,0x3E,0x00,0x3C,0x00,0x43,0x00,0x48,0x00,0x45,0x00,0x43,0x00,0x4B,0x00,0x53,0x00,0x55,0x00,\r
1082                                         0x4D,0x00,0x3E,0x00,0x42,0x00,0x47,0x00,0x77,0x00,0x31,0x00,0x61,0x00,0x59,0x00,0x5A,0x00,0x31,0x00,0x59,0x00,0x58,0x00,0x4D,0x00,0x3D,0x00,0x3C,0x00,\r
1083                                         0x2F,0x00,0x43,0x00,0x48,0x00,0x45,0x00,0x43,0x00,0x4B,0x00,0x53,0x00,0x55,0x00,0x4D,0x00,0x3E,0x00,0x3C,0x00,0x43,0x00,0x55,0x00,0x53,0x00,0x54,0x00,\r
1084                                         0x4F,0x00,0x4D,0x00,0x41,0x00,0x54,0x00,0x54,0x00,0x52,0x00,0x49,0x00,0x42,0x00,0x55,0x00,0x54,0x00,0x45,0x00,0x53,0x00,0x3E,0x00,0x3C,0x00,0x49,0x00,\r
1085                                         0x49,0x00,0x53,0x00,0x5F,0x00,0x44,0x00,0x52,0x00,0x4D,0x00,0x5F,0x00,0x56,0x00,0x45,0x00,0x52,0x00,0x53,0x00,0x49,0x00,0x4F,0x00,0x4E,0x00,0x3E,0x00,\r
1086                                         0x37,0x00,0x2E,0x00,0x31,0x00,0x2E,0x00,0x31,0x00,0x30,0x00,0x36,0x00,0x34,0x00,0x2E,0x00,0x30,0x00,0x3C,0x00,0x2F,0x00,0x49,0x00,0x49,0x00,0x53,0x00,\r
1087                                         0x5F,0x00,0x44,0x00,0x52,0x00,0x4D,0x00,0x5F,0x00,0x56,0x00,0x45,0x00,0x52,0x00,0x53,0x00,0x49,0x00,0x4F,0x00,0x4E,0x00,0x3E,0x00,0x3C,0x00,0x2F,0x00,\r
1088                                         0x43,0x00,0x55,0x00,0x53,0x00,0x54,0x00,0x4F,0x00,0x4D,0x00,0x41,0x00,0x54,0x00,0x54,0x00,0x52,0x00,0x49,0x00,0x42,0x00,0x55,0x00,0x54,0x00,0x45,0x00,\r
1089                                         0x53,0x00,0x3E,0x00,0x3C,0x00,0x4C,0x00,0x41,0x00,0x5F,0x00,0x55,0x00,0x52,0x00,0x4C,0x00,0x3E,0x00,0x68,0x00,0x74,0x00,0x74,0x00,0x70,0x00,0x3A,0x00,\r
1090                                         0x2F,0x00,0x2F,0x00,0x70,0x00,0x6C,0x00,0x61,0x00,0x79,0x00,0x72,0x00,0x65,0x00,0x61,0x00,0x64,0x00,0x79,0x00,0x2E,0x00,0x64,0x00,0x69,0x00,0x72,0x00,\r
1091                                         0x65,0x00,0x63,0x00,0x74,0x00,0x74,0x00,0x61,0x00,0x70,0x00,0x73,0x00,0x2E,0x00,0x6E,0x00,0x65,0x00,0x74,0x00,0x2F,0x00,0x70,0x00,0x72,0x00,0x2F,0x00,\r
1092                                         0x73,0x00,0x76,0x00,0x63,0x00,0x2F,0x00,0x72,0x00,0x69,0x00,0x67,0x00,0x68,0x00,0x74,0x00,0x73,0x00,0x6D,0x00,0x61,0x00,0x6E,0x00,0x61,0x00,0x67,0x00,\r
1093                                         0x65,0x00,0x72,0x00,0x2E,0x00,0x61,0x00,0x73,0x00,0x6D,0x00,0x78,0x00,0x3C,0x00,0x2F,0x00,0x4C,0x00,0x41,0x00,0x5F,0x00,0x55,0x00,0x52,0x00,0x4C,0x00,\r
1094                                         0x3E,0x00,0x3C,0x00,0x44,0x00,0x53,0x00,0x5F,0x00,0x49,0x00,0x44,0x00,0x3E,0x00,0x41,0x00,0x48,0x00,0x2B,0x00,0x30,0x00,0x33,0x00,0x6A,0x00,0x75,0x00,\r
1095                                         0x4B,0x00,0x62,0x00,0x55,0x00,0x47,0x00,0x62,0x00,0x48,0x00,0x6C,0x00,0x31,0x00,0x56,0x00,0x2F,0x00,0x51,0x00,0x49,0x00,0x77,0x00,0x52,0x00,0x41,0x00,\r
1096                                         0x3D,0x00,0x3D,0x00,0x3C,0x00,0x2F,0x00,0x44,0x00,0x53,0x00,0x5F,0x00,0x49,0x00,0x44,0x00,0x3E,0x00,0x3C,0x00,0x2F,0x00,0x44,0x00,0x41,0x00,0x54,0x00,\r
1097                                         0x41,0x00,0x3E,0x00,0x3C,0x00,0x2F,0x00,0x57,0x00,0x52,0x00,0x4D,0x00,0x48,0x00,0x45,0x00,0x41,0x00,0x44,0x00,0x45,0x00,0x52,0x00,0x3E,0x00,0x00,0x00};\r
1098 \r
1099                         memset(&license_info, 0x00, sizeof(drm_trusted_piff_get_license_info_s));\r
1100 \r
1101                         license_info.lic_header.header = (unsigned char*)ContentHeader;\r
1102                         license_info.lic_header.header_len = sizeof(ContentHeader);\r
1103                         ret = drm_trusted_handle_request(request_type,(void *)&license_info,NULL);\r
1104                         DRM_TRUSTED_CLIENT_TEST_LOG("ret=0x%x", ret);\r
1105                         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
1106                         DRM_TRUSTED_CLIENT_TEST_LOG("PIFF_GET_LICENSE Success!!");\r
1107                         } else {\r
1108                                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("PIFF_GET_LICENSE Failed!!, ret=0x%x", ret);\r
1109                         }\r
1110                         break;\r
1111                 }\r
1112 \r
1113                 case DRM_TRUSTED_REQ_TYPE_SAPPS_DECRYPT_PACKAGE:\r
1114                 {\r
1115                         int ret = -1;\r
1116                         drm_trusted_sapps_decrypt_package_info_s package_info;\r
1117 \r
1118                         memset(&package_info, 0x00, sizeof(drm_trusted_sapps_decrypt_package_info_s));\r
1119                         DRM_TRUSTED_CLIENT_TEST_LOG("Enter Samsung Apps DRM File Path");\r
1120                         scanf("%s",package_info.sadcf_filepath);\r
1121 \r
1122                         DRM_TRUSTED_CLIENT_TEST_LOG("Enter Decrypted File Path");\r
1123                         scanf("%s",package_info.decrypt_filepath);\r
1124 \r
1125                         DRM_TRUSTED_CLIENT_TEST_LOG("SamsungAppsDRMFilePath=%s",package_info.sadcf_filepath);\r
1126                         DRM_TRUSTED_CLIENT_TEST_LOG("Decrypted-FilePath=%s",package_info.decrypt_filepath);\r
1127 \r
1128                         ret = drm_trusted_handle_request(request_type,(void *)&package_info,NULL);\r
1129                         DRM_TRUSTED_CLIENT_TEST_LOG("ret=0x%x", ret);\r
1130                         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
1131                         DRM_TRUSTED_CLIENT_TEST_LOG("SAPPS_DECRYPT_PACKAGE Success!!");\r
1132                         } else {\r
1133                                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("SAPPS_DECRYPT_PACKAGE Failed!!, ret=0x%x", ret);\r
1134                         }\r
1135                         break;\r
1136                 }\r
1137 \r
1138                 case DRM_TRUSTED_REQ_TYPE_SAPPS_CONSUME_LICENSE:\r
1139                 {\r
1140                         int ret = -1;\r
1141                         drm_trusted_sapps_consume_license_info_s cons_license_info;\r
1142 \r
1143                         memset(&cons_license_info, 0x00, sizeof(drm_trusted_sapps_consume_license_info_s));\r
1144                         ret = drm_trusted_handle_request(request_type,(void *)&cons_license_info,NULL);\r
1145                         DRM_TRUSTED_CLIENT_TEST_LOG("ret=0x%x", ret);\r
1146                         if (DRM_TRUSTED_RETURN_SUCCESS == ret) {\r
1147                         DRM_TRUSTED_CLIENT_TEST_LOG("SAPPS_CONSUME_LICENSE Success!!");\r
1148                         } else {\r
1149                                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("SAPPS_CONSUME_LICENSE Failed!!, ret=0x%x", ret);\r
1150                         }\r
1151                         break;\r
1152                 }\r
1153 \r
1154                 case DRM_TRUSTED_REQ_TYPE_SAPPS_GENERATE_PURCHASE_REQUEST:\r
1155                 {\r
1156                         DRM_TRUSTED_CLIENT_TEST_EXCEPTION("Test-environment is not available:"\r
1157                                         "DRM_TRUSTED_REQ_TYPE_SAPPS_GENERATE_PURCHASE_REQUEST");\r
1158                         break;\r
1159                 }\r
1160 \r
1161                 case DRM_TRUSTED_REQ_TYPE_SAPPS_GENERATE_LICENSE_REQUEST:\r
1162                 {\r
1163                         DRM_TRUSTED_CLIENT_TEST_EXCEPTION("Test-environment is not available:"\r
1164                                         "DRM_TRUSTED_REQ_TYPE_SAPPS_GENERATE_LICENSE_REQUEST");\r
1165                         break;\r
1166                 }\r
1167 \r
1168                 default:\r
1169                 {\r
1170                         DRM_TRUSTED_CLIENT_TEST_EXCEPTION("Invalid option!!");\r
1171                         break;\r
1172                 }\r
1173 \r
1174                 }\r
1175 \r
1176                 break;\r
1177         }\r
1178 \r
1179         case DRM_TRUSTED_CLIENT_TEST_consume_content:\r
1180         {\r
1181                 DRM_TRUSTED_CLIENT_TEST_LOG("DRM_TRUSTED_CLIENT_TEST_consume_content");\r
1182                 test_consume_content();\r
1183                 break;\r
1184         }\r
1185 \r
1186         case DRM_TRUSTED_CLIENT_TEST_CONVERT:\r
1187         {\r
1188                 DRM_TRUSTED_CLIENT_TEST_LOG("Your choice is DRM_TRUSTED_CLIENT_TEST_CONVERT");\r
1189                 DRM_TRUSTED_CLIENT_TEST_LOG("Enter complete Source file path");\r
1190                 scanf("%s", filePath);\r
1191                 DRM_TRUSTED_CLIENT_TEST_LOG("Enter complete Destination file path");\r
1192                 scanf("%s", distfilePath);\r
1193                 DRM_TRUSTED_CLIENT_TEST_LOG("test_convert: sourcefile=%s destfile=%s",filePath,distfilePath);\r
1194                 test_convert(filePath,distfilePath);\r
1195                 DRM_TRUSTED_CLIENT_TEST_LOG("test_convert finishes");\r
1196                 break;\r
1197         }\r
1198 \r
1199         case DRM_TRUSTED_CLIENT_TEST_MAX:\r
1200         {\r
1201                 DRM_TRUSTED_CLIENT_TEST_LOG("DRM_TRUSTED_CLIENT_TEST_MAX");\r
1202                 DRM_TRUSTED_CLIENT_TEST_LOG("SUCCESS");\r
1203                 return 0;\r
1204         }\r
1205 \r
1206         default:\r
1207                 DRM_TRUSTED_CLIENT_TEST_EXCEPTION("Wrong choice=%d",option);\r
1208                 goto ERR;\r
1209         }\r
1210 \r
1211         DRM_TRUSTED_CLIENT_TEST_LOG("SUCCESS");\r
1212         return 1;\r
1213 \r
1214 ERR:\r
1215         DRM_TRUSTED_CLIENT_TEST_EXCEPTION("test_case:Error:Exit from DRM CLIENT Test utility");\r
1216         return 0;\r
1217 }\r
1218 \r
1219 int main(int argc, char* argv[])\r
1220 {\r
1221         int pid = getpid();\r
1222         int choice = DRM_TRUSTED_CLIENT_TEST_NONE;\r
1223         DRM_TRUSTED_CLIENT_TEST_LOG("main:pid=[%d]", pid);\r
1224 \r
1225         do {\r
1226                 DRM_TRUSTED_CLIENT_TEST_LOG("choice=%d -> DRM_TRUSTED_CLIENT_TEST_NONE",DRM_TRUSTED_CLIENT_TEST_NONE);\r
1227                 DRM_TRUSTED_CLIENT_TEST_LOG("choice=%d -> DRM_TRUSTED_CLIENT_TEST_handle_request",DRM_TRUSTED_CLIENT_TEST_handle_request);\r
1228                 DRM_TRUSTED_CLIENT_TEST_LOG("choice=%d -> DRM_TRUSTED_CLIENT_TEST_consume_content",DRM_TRUSTED_CLIENT_TEST_consume_content);\r
1229                 DRM_TRUSTED_CLIENT_TEST_LOG("choice=%d -> DRM_TRUSTED_CLIENT_TEST_CONVERT",DRM_TRUSTED_CLIENT_TEST_CONVERT);\r
1230                 DRM_TRUSTED_CLIENT_TEST_LOG("choice=%d -> Exit from TEST Script",DRM_TRUSTED_CLIENT_TEST_MAX);\r
1231                 DRM_TRUSTED_CLIENT_TEST_LOG("Enter Your choice:1 to %d:Use choice no-%d to exit the test-program",DRM_TRUSTED_CLIENT_TEST_MAX, DRM_TRUSTED_CLIENT_TEST_MAX);\r
1232                 scanf("%3d", &choice);\r
1233         } while (1 == test_case(choice));\r
1234 \r
1235         DRM_TRUSTED_CLIENT_TEST_LOG("Exiting process=[%d] from main", pid);\r
1236         return 0;\r
1237 }\r