service/drm_client.cpp

   1 /*\r
   2  * drm-client\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 /**\r
  27  * @file                drm_client.cpp\r
  28  * @brief       DRM Client API defintions.\r
  29  * @author      Mahendra Kumar Prajapat (mahendra.p@samsung.com)\r
  30  * @author      Harsha Shekar (h.shekar@samsung.com)\r
  31  * @version     0.1\r
  32  * @history     0.1: First version of DRM Client API Definitions.\r
  33  */\r
  34 \r
  35 #include <stdlib.h>\r
  36 #include <string.h>\r
  37 #include <malloc.h>\r
  38 \r
  39 #include "drm_client.h"\r
  40 #include "drm_client_ipc.h"\r
  41 #include "drm_client_log.h"\r
  42 //#include "security-server.h"\r
  43 \r
  44 #include <glib.h>\r
  45 \r
  46 #ifndef EXPORT_API\r
  47 #define EXPORT_API __attribute__((visibility("default")))\r
  48 #endif\r
  49 \r
  50 \r
  51 \r
  52 /**\r
  53  *  Private function\r
  54  *\r
  55  *\r
  56  * @param[in]   file_path               Specifies the pointer points a DRM file path.\r
  57  * @return              This function returns DRM file type.\r
  58  * @remarks\r
  59  * @see\r
  60  * @since       0.1\r
  61  */\r
  62 static drm_file_type_e _drm_client_get_file_type(const char* file_path);\r
  63 \r
  64 /**\r
  65  *  An application can check that a file is DRM file\r
  66  *  (OMA DRM, PlayReady, DivX etc.)\r
  67  *\r
  68  * @param[in]   file_path               Specifies the pointer points a DRM file path.\r
  69  * @param[out]  is_drm_file     DRM_TRUE if the input file is a DRM file\r
  70  *                                                              else DRM_FALSE.\r
  71  * @return              0 on success, else a negative error value\r
  72  * @retval              DRM_RETURN_SUCCESS on success\r
  73  * @retval              DRM_RETURN_INVALID_ARG if arguments are invalid\r
  74  * @retval              DRM_RETURN_COMMUNICATION_ERROR if socket error\r
  75  * @retval              DRM_RETURN_INTERNAL_ERROR if operation error\r
  76  *\r
  77  * @remarks\r
  78  * @see\r
  79  * @since       0.1\r
  80  */\r
  81 EXPORT_API int drm_is_drm_file(const char *file_path,\r
  82                 drm_bool_type_e *is_drm_file)\r
  83 {\r
  84         DRM_CLIENT_LOG("Enter: file_path = %s", (!file_path) ? NULL:file_path);\r
  85         drm_request_data_s req_data;\r
  86         drm_response_data_s resp_data;\r
  87         int ret_comm = 0;\r
  88         drm_file_type_e file_type = DRM_TYPE_UNDEFINED;\r
  89         int ret_cpy = 0;\r
  90 \r
  91         /* Check input parameters */\r
  92         if (!file_path || '\0' == file_path[0] || !is_drm_file) {\r
  93                 DRM_CLIENT_EXCEPTION("Invalid Arg!!, file_path = %p, is_drm_file = %p",\r
  94                                 file_path, is_drm_file);\r
  95                 return DRM_RETURN_INVALID_ARG;\r
  96         }\r
  97 \r
  98         file_type = _drm_client_get_file_type(file_path);\r
  99 \r
 100         switch (file_type) {\r
 101         case DRM_TYPE_OMA_V1:\r
 102         case DRM_TYPE_OMA_V2:\r
 103         case DRM_TYPE_PLAYREADY:\r
 104         case DRM_TYPE_PLAYREADY_ENVELOPE:\r
 105                 /* All the above 4 cases correspond to a file being DRM file! */\r
 106                 DRM_CLIENT_LOG("file_type = %d", file_type);\r
 107                 *is_drm_file = DRM_TRUE;\r
 108                 break;\r
 109 \r
 110         case DRM_TYPE_DIVX: {\r
 111 \r
 112                 /* memset the structures */\r
 113                 memset(&req_data, 0x0, sizeof(drm_request_data_s));\r
 114                 memset(&resp_data, 0x0, sizeof(drm_response_data_s));\r
 115 \r
 116                 /* In this case, further analysis of headers required to identify DRM file */\r
 117                 /* Contact the server to perform operations */\r
 118 \r
 119                 /* Store the input parameters to the Request Data structure to be sent to server */\r
 120                 if ((ret_cpy = g_strlcpy(req_data.fixed_data.request_data, file_path,\r
 121                                 DRM_MAX_LEN_FILEPATH)) >= DRM_MAX_LEN_FILEPATH) {\r
 122                         DRM_CLIENT_EXCEPTION("file_path = %s, filepath_len = %d, ret_cpy = %d",\r
 123                                         file_path, strlen(file_path), ret_cpy);\r
 124                         return DRM_RETURN_INVALID_ARG;\r
 125                 }\r
 126 \r
 127                 /* Tell the server which API to be used */\r
 128                 req_data.fixed_data.api_name = DRM_IS_DRM_FILE;\r
 129 \r
 130                 /* Call the Client Communication API */\r
 131                 if ((ret_comm = drm_client_comm(&req_data, &resp_data)) != 0) {\r
 132                         DRM_CLIENT_EXCEPTION("drm_client_comm error!!, ret_comm = %d", ret_comm);\r
 133                         return DRM_RETURN_COMMUNICATION_ERROR;\r
 134                 }\r
 135 \r
 136                 /* Copy the response obtained from the server into the output parameter */\r
 137                 if (resp_data.fixed_data.resp_result != 0) {\r
 138                         DRM_CLIENT_EXCEPTION("Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
 139                                         resp_data.fixed_data.resp_result);\r
 140                         *is_drm_file = DRM_FALSE;\r
 141                         goto ErrorExit;\r
 142                 } else {\r
 143                         DRM_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x", resp_data.fixed_data.resp_result);\r
 144                         *is_drm_file = resp_data.fixed_data.bool_val;\r
 145                 }\r
 146 \r
 147         }\r
 148                 break;\r
 149 \r
 150         case DRM_TYPE_UNDEFINED:\r
 151                 DRM_CLIENT_LOG("file_type = %d", file_type);\r
 152                 *is_drm_file = DRM_FALSE;\r
 153                 break;\r
 154 \r
 155         default:\r
 156                 DRM_CLIENT_EXCEPTION("Undefined file type!!");\r
 157                 *is_drm_file = DRM_FALSE;\r
 158                 goto ErrorExit;\r
 159         }\r
 160 \r
 161         DRM_CLIENT_LOG("Exit:Success!!, is_drm_file = %d",\r
 162                         *is_drm_file);\r
 163         return DRM_RETURN_SUCCESS;\r
 164 \r
 165 ErrorExit:\r
 166         DRM_CLIENT_EXCEPTION("Exit:failed!!, is_drm_file = %d",\r
 167                         *is_drm_file);\r
 168         return DRM_RETURN_INTERNAL_ERROR;\r
 169 \r
 170 }\r
 171 \r
 172 /**\r
 173  *  An application can get DRM file type of the file that is\r
 174  *  specified in file_path\r
 175  *\r
 176  * @param[in]   file_path       Specifies the pointer points a DRM file path.\r
 177  * @param[out]  file_type       DRM file type.\r
 178  * @return              0 on success, else a negative error value\r
 179  * @retval              DRM_RETURN_SUCCESS on success\r
 180  * @retval              DRM_RETURN_INVALID_ARG if arguments are invalid\r
 181  * @remarks\r
 182  * @see\r
 183  * @since       0.1\r
 184  */\r
 185 EXPORT_API int drm_get_file_type(const char *file_path, drm_file_type_e *file_type)\r
 186 {\r
 187         DRM_CLIENT_LOG("Enter: file_path = %s", (!file_path) ? NULL:file_path);\r
 188 \r
 189         /* Check input parameters */\r
 190         if (!file_path || '\0' == file_path[0] || !file_type) {\r
 191                 DRM_CLIENT_EXCEPTION("Invalid Arg!!, file_path = %p, file_type = %p",\r
 192                                 file_path, file_type);\r
 193                 return DRM_RETURN_INVALID_ARG;\r
 194         }\r
 195 \r
 196         *file_type = _drm_client_get_file_type(file_path);\r
 197         DRM_CLIENT_LOG("Exit:Success!! file_type = %d", *file_type);\r
 198         return DRM_RETURN_SUCCESS;\r
 199 }\r
 200 \r
 201 /**\r
 202  * An application can check that a DRM file has valid license or not.\r
 203  *\r
 204  * @param[in]   file_path               DRM file path.\r
 205  * @param[in]   perm_type               Enumeration type of permission.\r
 206  * @param[out]  license_status  license status.\r
 207  * @return              0 on success, else a negative error value\r
 208  * @retval              DRM_RETURN_SUCCESS on success\r
 209  * @retval              DRM_RETURN_INVALID_ARG if arguments are invalid\r
 210  * @retval              DRM_RETURN_COMMUNICATION_ERROR if socket error\r
 211  * @retval              DRM_RETURN_INTERNAL_ERROR if operation error\r
 212  * @remarks\r
 213  * @see\r
 214  * @since       0.1\r
 215  */\r
 216 EXPORT_API int drm_get_license_status(const char *file_path,\r
 217                 drm_permission_type_e perm_type,\r
 218                 drm_license_status_e *license_status)\r
 219 {\r
 220         DRM_CLIENT_LOG("Enter: file_path = %s, perm_type = %d",\r
 221                         (!file_path) ? NULL:file_path, perm_type);\r
 222 \r
 223         drm_request_data_s req_data;\r
 224         drm_response_data_s resp_data;\r
 225         int ret_comm = 0;\r
 226         drm_result_e result = DRM_RETURN_SUCCESS;\r
 227         int ret_cpy = 0;\r
 228 \r
 229         /* memset the structures */\r
 230         memset(&req_data, 0x0, sizeof(drm_request_data_s));\r
 231         memset(&resp_data, 0x0, sizeof(drm_response_data_s));\r
 232 \r
 233         /* Check input parameters */\r
 234         if (!file_path || '\0' == file_path[0] || !license_status) {\r
 235                 DRM_CLIENT_EXCEPTION("Invalid Arg!!, file_path = %p, license_status = %p",\r
 236                                 file_path, license_status);\r
 237                 return DRM_RETURN_INVALID_ARG;\r
 238         }\r
 239 \r
 240         /* Store the input parameters to the Request Data structure to be sent to server */\r
 241         if ((ret_cpy = g_strlcpy(req_data.fixed_data.request_data, file_path,\r
 242                         DRM_MAX_LEN_FILEPATH)) >= DRM_MAX_LEN_FILEPATH) {\r
 243                 DRM_CLIENT_EXCEPTION("file_path = %s, filepath_len = %d, ret_cpy = %d",\r
 244                                 file_path, strlen(file_path), ret_cpy);\r
 245                 return DRM_RETURN_INVALID_ARG;\r
 246         }\r
 247 \r
 248         req_data.fixed_data.permission_type = perm_type;\r
 249 \r
 250         /* Tell the server which API to be used */\r
 251         req_data.fixed_data.api_name = DRM_GET_LICENSE_STATUS;\r
 252 \r
 253         /* Send Data to DRM server */\r
 254         /* Call the Client Communication API */\r
 255         if ((ret_comm = drm_client_comm(&req_data, &resp_data)) != 0) {\r
 256                 DRM_CLIENT_EXCEPTION("drm_client_comm error!!, ret_comm = %d", ret_comm);\r
 257                 result = DRM_RETURN_COMMUNICATION_ERROR;\r
 258                 goto ErrorExit;\r
 259         }\r
 260 \r
 261         /* Copy the response obtained from the server into the output parameter */\r
 262         if (resp_data.fixed_data.resp_result != 0) {\r
 263                 DRM_CLIENT_EXCEPTION("Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
 264                                 resp_data.fixed_data.resp_result);\r
 265                 *license_status = DRM_LICENSE_STATUS_UNDEFINED;\r
 266                 result = resp_data.fixed_data.resp_result;\r
 267                 goto ErrorExit;\r
 268         } else {\r
 269                 DRM_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x", resp_data.fixed_data.resp_result);\r
 270                 *license_status = resp_data.fixed_data.lic_status;\r
 271         }\r
 272 \r
 273         DRM_CLIENT_LOG("*license_status = %d", *license_status);\r
 274 \r
 275 ErrorExit:\r
 276         if (result != DRM_RETURN_SUCCESS) {\r
 277                 DRM_CLIENT_EXCEPTION("Exit:failed!!, result = 0x%x", result);\r
 278         } else {\r
 279                 DRM_CLIENT_LOG("Exit:Success!!, result = 0x%x", result);\r
 280         }\r
 281 \r
 282         return result;\r
 283 }\r
 284 \r
 285 /**\r
 286  * An application can get DRM Content information for the file\r
 287  * specified in file_path.\r
 288  *\r
 289  * @param[in]   file_path               DRM file path.\r
 290  * @param[out]  content_info    Content information.\r
 291  * @return              0 on success, else a negative error value\r
 292  * @retval              DRM_RETURN_SUCCESS on success\r
 293  * @retval              DRM_RETURN_INVALID_ARG if arguments are invalid\r
 294  * @retval              DRM_RETURN_COMMUNICATION_ERROR if socket error\r
 295  * @retval              DRM_RETURN_INTERNAL_ERROR if operation error\r
 296  * @remarks\r
 297  * @see\r
 298  * @since       0.1\r
 299  */\r
 300 EXPORT_API int drm_get_content_info(const char *file_path,\r
 301                 drm_content_info_s *content_info)\r
 302 {\r
 303         DRM_CLIENT_LOG("Enter: file_path = %s", (!file_path) ? NULL:file_path);\r
 304 \r
 305         drm_request_data_s req_data;\r
 306         drm_response_data_s resp_data;\r
 307         int ret_comm = 0;\r
 308         drm_result_e result = DRM_RETURN_SUCCESS;\r
 309         int ret_cpy = 0;\r
 310 \r
 311         /* memset the structures */\r
 312         memset(&req_data, 0x0, sizeof(drm_request_data_s));\r
 313         memset(&resp_data, 0x0, sizeof(drm_response_data_s));\r
 314 \r
 315         /* Check input parameters */\r
 316         if (!file_path || '\0' == file_path[0] || !content_info) {\r
 317                 DRM_CLIENT_EXCEPTION("Invalid Arg!!, file_path = %p, content_info = %p",\r
 318                                 file_path, content_info);\r
 319                 return DRM_RETURN_INVALID_ARG;\r
 320         }\r
 321 \r
 322         /* memset the output structure */\r
 323         memset(content_info, 0x00, sizeof(drm_content_info_s));\r
 324 \r
 325         /* Store the input parameters to the Request Data structure to be sent to server */\r
 326         if ((ret_cpy = g_strlcpy(req_data.fixed_data.request_data, file_path,\r
 327                         DRM_MAX_LEN_FILEPATH)) >= DRM_MAX_LEN_FILEPATH) {\r
 328                 DRM_CLIENT_EXCEPTION("file_path = %s, filepath_len = %d, ret_cpy = %d",\r
 329                                 file_path, strlen(file_path), ret_cpy);\r
 330                 return DRM_RETURN_INVALID_ARG;\r
 331         }\r
 332 \r
 333         /* Tell the server which API to be used */\r
 334         req_data.fixed_data.api_name = DRM_GET_CONTENT_INFO;\r
 335 \r
 336         /* Send Data to DRM server */\r
 337         /* Call the Client Communication API */\r
 338         if ((ret_comm = drm_client_comm(&req_data, &resp_data)) != 0) {\r
 339                 DRM_CLIENT_EXCEPTION("drm_client_comm error!!, ret_comm = %d", ret_comm);\r
 340                 result = DRM_RETURN_COMMUNICATION_ERROR;\r
 341                 goto ErrorExit;\r
 342         }\r
 343 \r
 344         /* Copy the response obtained from the server into the output parameter */\r
 345         if (resp_data.fixed_data.resp_result != 0) {\r
 346                 DRM_CLIENT_EXCEPTION("Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
 347                                 resp_data.fixed_data.resp_result);\r
 348                 memset(content_info, 0x00, sizeof(drm_content_info_s));\r
 349                 result = resp_data.fixed_data.resp_result;\r
 350                 goto ErrorExit;\r
 351         } else {\r
 352                 DRM_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x", resp_data.fixed_data.resp_result);\r
 353                 memcpy(content_info, &resp_data.fixed_data.response_data, sizeof(drm_content_info_s));\r
 354         }\r
 355 \r
 356         DRM_CLIENT_LOG("content_info->author = %s", content_info->author);\r
 357         DRM_CLIENT_LOG("content_info->content_id = %s", content_info->content_id);\r
 358         DRM_CLIENT_LOG("content_info->content_url = %s", content_info->content_url);\r
 359         DRM_CLIENT_LOG("content_info->copyright = %s", content_info->copyright);\r
 360         DRM_CLIENT_LOG("content_info->description = %s", content_info->description);\r
 361         DRM_CLIENT_LOG("content_info->icon_uri = %s", content_info->icon_uri);\r
 362         DRM_CLIENT_LOG("content_info->info_url = %s", content_info->info_url);\r
 363         DRM_CLIENT_LOG("content_info->mime_type = %s", content_info->mime_type);\r
 364         DRM_CLIENT_LOG("content_info->rights_url = %s", content_info->rights_url);\r
 365         DRM_CLIENT_LOG("content_info->title = %s", content_info->title);\r
 366 \r
 367 ErrorExit:\r
 368 if (result != DRM_RETURN_SUCCESS) {\r
 369                 DRM_CLIENT_EXCEPTION("Exit:failed!!, result = 0x%x", result);\r
 370         } else {\r
 371                 DRM_CLIENT_LOG("Exit:Success!!, result = 0x%x", result);\r
 372         }\r
 373 \r
 374         return result;\r
 375 }\r
 376 \r
 377 /**\r
 378  * An application can get file information of a DRM file.\r
 379  *\r
 380  * @param[in]   file_path               DRM file path.\r
 381  * @param[out]  fileInfo                DRM file info.\r
 382  * @return              0 on success, else a negative error value\r
 383  * @retval              DRM_RETURN_SUCCESS on success\r
 384  * @retval              DRM_RETURN_INVALID_ARG if arguments are invalid\r
 385  * @retval              DRM_RETURN_COMMUNICATION_ERROR if socket error\r
 386  * @retval              DRM_RETURN_INTERNAL_ERROR if operation error\r
 387  * @remarks\r
 388  * @see\r
 389  * @since       0.1\r
 390  */\r
 391 EXPORT_API int drm_get_file_info(const char *file_path,\r
 392                 drm_file_info_s *fileInfo)\r
 393 {\r
 394         DRM_CLIENT_LOG("Enter: file_path = %s", (!file_path) ? NULL:file_path);\r
 395         drm_request_data_s req_data;\r
 396         drm_response_data_s resp_data;\r
 397         int ret_comm = 0;\r
 398         drm_result_e result = DRM_RETURN_SUCCESS;\r
 399         int ret_cpy = 0;\r
 400 \r
 401         /* memset the structures */\r
 402         memset(&req_data, 0x0, sizeof(drm_request_data_s));\r
 403         memset(&resp_data, 0x0, sizeof(drm_response_data_s));\r
 404 \r
 405         /* Check input parameters */\r
 406         if (!file_path || '\0' == file_path[0] || !fileInfo) {\r
 407                 DRM_CLIENT_EXCEPTION("Invalid Arg!!, file_path = %p, fileInfo = %p",\r
 408                                 file_path, fileInfo);\r
 409                 return DRM_RETURN_INVALID_ARG;\r
 410         }\r
 411 \r
 412         DRM_CLIENT_LOG("file_path = %s", file_path);\r
 413 \r
 414         /* memset the output structure */\r
 415         memset(fileInfo, 0x00, sizeof(drm_file_info_s));\r
 416 \r
 417         /* Store the input parameters to the Request Data structure to be sent to server */\r
 418         if ((ret_cpy = g_strlcpy(req_data.fixed_data.request_data, file_path,\r
 419                         DRM_MAX_LEN_FILEPATH)) >= DRM_MAX_LEN_FILEPATH) {\r
 420                 DRM_CLIENT_EXCEPTION("file_path = %s, filepath_len = %d, ret_cpy = %d",\r
 421                                 file_path, strlen(file_path), ret_cpy);\r
 422                 return DRM_RETURN_INVALID_ARG;\r
 423         }\r
 424 \r
 425         /* Tell the server which API to be used */\r
 426         req_data.fixed_data.api_name = DRM_GET_FILE_INFO;\r
 427 \r
 428         /* Send Data to DRM server */\r
 429         /* Call the Client Communication API */\r
 430         if ((ret_comm = drm_client_comm(&req_data, &resp_data)) != 0) {\r
 431                 DRM_CLIENT_EXCEPTION("drm_client_comm error!!, ret_comm = %d", ret_comm);\r
 432                 result = DRM_RETURN_COMMUNICATION_ERROR;\r
 433                 goto ErrorExit;\r
 434         }\r
 435 \r
 436         /* Copy the response obtained from the server into the output parameter */\r
 437         if (resp_data.fixed_data.resp_result != 0) {\r
 438                 DRM_CLIENT_EXCEPTION("Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
 439                                 resp_data.fixed_data.resp_result);\r
 440                 memset(fileInfo, 0x00, sizeof(drm_file_info_s));\r
 441                 result = resp_data.fixed_data.resp_result;\r
 442                 goto ErrorExit;\r
 443         } else {\r
 444                 DRM_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x", resp_data.fixed_data.resp_result);\r
 445                 memcpy(fileInfo, &resp_data.fixed_data.response_data, sizeof(drm_file_info_s));\r
 446         }\r
 447 \r
 448         DRM_CLIENT_LOG("fileInfo->oma_info.method = %d", fileInfo->oma_info.method);\r
 449         DRM_CLIENT_LOG("fileInfo->oma_info.version = %d", fileInfo->oma_info.version);\r
 450 \r
 451 ErrorExit:\r
 452         if (result != DRM_RETURN_SUCCESS) {\r
 453                 DRM_CLIENT_EXCEPTION("Exit:failed!!, result = 0x%x", result);\r
 454         } else {\r
 455                 DRM_CLIENT_LOG("Exit:Success!!, result = 0x%x", result);\r
 456         }\r
 457         return result;\r
 458 }\r
 459 \r
 460 /**\r
 461  * An application can get constraints associated with\r
 462  * given permission & given file\r
 463  *\r
 464  * @param[in]   file_path                       DRM file path.\r
 465  * @param[in]   perm_type                       Enumeration type of permission.\r
 466  * @param[out]  constraint_info         Constraint info.\r
 467  * @return              0 on success, else a negative error value\r
 468  * @retval              DRM_RETURN_SUCCESS on success\r
 469  * @retval              DRM_RETURN_INVALID_ARG if arguments are invalid\r
 470  * @retval              DRM_RETURN_COMMUNICATION_ERROR if socket error\r
 471  * @retval              DRM_RETURN_INTERNAL_ERROR if operation error\r
 472  * @remarks\r
 473  * @see\r
 474  * @since       0.1\r
 475  */\r
 476 EXPORT_API int drm_get_constraint_info(const char *file_path,\r
 477                 drm_permission_type_e perm_type,\r
 478                 drm_constraint_info_s *constraint_info)\r
 479 {\r
 480         DRM_CLIENT_LOG("Enter: file_path = %s, perm_type = %d",\r
 481                         (!file_path) ? NULL:file_path, perm_type);\r
 482 \r
 483         drm_request_data_s req_data;\r
 484         drm_response_data_s resp_data;\r
 485         int ret_comm = 0;\r
 486         drm_result_e result = DRM_RETURN_SUCCESS;\r
 487         int ret_cpy = 0;\r
 488 \r
 489         /* memset the structures */\r
 490         memset(&req_data, 0x0, sizeof(drm_request_data_s));\r
 491         memset(&resp_data, 0x0, sizeof(drm_response_data_s));\r
 492 \r
 493         /* Check input parameters */\r
 494         if (!file_path || '\0' == file_path[0] || !constraint_info) {\r
 495                 DRM_CLIENT_EXCEPTION("Invalid Arg!!, file_path = %p, constraint_info = %p",\r
 496                                 file_path, constraint_info);\r
 497                 return DRM_RETURN_INVALID_ARG;\r
 498         }\r
 499 \r
 500         DRM_CLIENT_LOG("file_path = %s, perm_type = %d", file_path, perm_type);\r
 501 \r
 502         /* memset the output structure */\r
 503         memset(constraint_info, 0x00, sizeof(drm_constraint_info_s));\r
 504 \r
 505         /* Store the input parameters to the Request Data structure to be sent to server */\r
 506         if ((ret_cpy = g_strlcpy(req_data.fixed_data.request_data, file_path,\r
 507                         DRM_MAX_LEN_FILEPATH)) >= DRM_MAX_LEN_FILEPATH) {\r
 508                 DRM_CLIENT_EXCEPTION("file_path = %s, filepath_len = %d, ret_cpy = %d",\r
 509                                 file_path, strlen(file_path), ret_cpy);\r
 510                 return DRM_RETURN_INVALID_ARG;\r
 511         }\r
 512         req_data.fixed_data.permission_type = perm_type;\r
 513 \r
 514         /* Tell the server which API to be used */\r
 515         req_data.fixed_data.api_name = DRM_GET_CONSTRAINT_INFO;\r
 516 \r
 517         /* Send Data to DRM server */\r
 518         /* Call the Client Communication API */\r
 519         if ((ret_comm = drm_client_comm(&req_data, &resp_data)) != 0) {\r
 520                 DRM_CLIENT_EXCEPTION("drm_client_comm error!!, ret_comm = %d", ret_comm);\r
 521                 result = DRM_RETURN_COMMUNICATION_ERROR;\r
 522                 goto ErrorExit;\r
 523         }\r
 524 \r
 525         /* Copy the response obtained from the server into the output parameter */\r
 526         if (resp_data.fixed_data.resp_result != 0) {\r
 527                 DRM_CLIENT_EXCEPTION("Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
 528                                 resp_data.fixed_data.resp_result);\r
 529                 memset(constraint_info, 0x00, sizeof(drm_constraint_info_s));\r
 530                 result = resp_data.fixed_data.resp_result;\r
 531                 goto ErrorExit;\r
 532         } else {\r
 533                 DRM_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x", resp_data.fixed_data.resp_result);\r
 534                 memcpy(constraint_info, &resp_data.fixed_data.response_data, sizeof(drm_constraint_info_s));\r
 535         }\r
 536 \r
 537 ErrorExit:\r
 538         if (result != DRM_RETURN_SUCCESS) {\r
 539                 DRM_CLIENT_EXCEPTION("Exit:failed!!, result = 0x%x", result);\r
 540         } else {\r
 541                 DRM_CLIENT_LOG("Exit:Success!!, result = 0x%x", result);\r
 542         }\r
 543         return result;\r
 544 }\r
 545 \r
 546 /**\r
 547  * An application can check the feasibility of actions to be\r
 548  * performed based on the type of DRM file.\r
 549  *\r
 550  * @param[in]   action                          Action to be taken.\r
 551  * @param[in]   action_data             Data needed to check action\r
 552  *                                                                      allowed operation\r
 553  * @param[out]  is_allowed                      DRM_TRUE if action is allowed\r
 554  *                                                                      else DRM_FALSE\r
 555  * @return              0 on success, else a negative error value\r
 556  * @retval              DRM_RETURN_SUCCESS on success\r
 557  * @retval              DRM_RETURN_INVALID_ARG if arguments are invalid\r
 558  * @retval              DRM_RETURN_COMMUNICATION_ERROR if socket error\r
 559  * @retval              DRM_RETURN_INTERNAL_ERROR if operation error\r
 560  * @remarks\r
 561  * @see\r
 562  * @since       0.1\r
 563  */\r
 564 EXPORT_API int drm_is_action_allowed(drm_action_type_e action,\r
 565                 drm_action_allowed_data_s *action_data,\r
 566                 drm_bool_type_e *is_allowed)\r
 567 {\r
 568         DRM_CLIENT_LOG("Enter: action = %d, action_data = %p", action, action_data);\r
 569         drm_request_data_s req_data;\r
 570         drm_response_data_s resp_data;\r
 571         int ret_comm = 0;\r
 572         drm_result_e result = DRM_RETURN_SUCCESS;\r
 573 \r
 574         /* memset the structures */\r
 575         memset(&req_data, 0x0, sizeof(drm_request_data_s));\r
 576         memset(&resp_data, 0x0, sizeof(drm_response_data_s));\r
 577 \r
 578         /* Check input parameters based on action type */\r
 579         switch(action){\r
 580         case DRM_IS_FORWARDING_ALLOWED:\r
 581         case DRM_HAS_VALID_SETAS_STATUS:\r
 582         {\r
 583                 /* Check input parameters */\r
 584                 if ((strlen(action_data->file_path)<=0) || !is_allowed) {\r
 585                         DRM_CLIENT_EXCEPTION("Invalid Arg!!, action_data->file_path = %p,"\r
 586                                         " is_allowed = %p", action_data->file_path, is_allowed);\r
 587                         return DRM_RETURN_INVALID_ARG;\r
 588                 }\r
 589                 DRM_CLIENT_LOG("action_data->file_path = %s, action = %d, data = %d",\r
 590                                 action_data->file_path, action, action_data->data);\r
 591 \r
 592                 /* Copy the input parameters to the Request structure */\r
 593                 req_data.fixed_data.action = action;\r
 594                 memcpy(req_data.fixed_data.request_data, action_data,\r
 595                                 sizeof(drm_action_allowed_data_s));\r
 596                 break;\r
 597         }\r
 598 \r
 599         case DRM_IS_DEVICE_ACTIVATED:\r
 600         case DRM_IS_VALID_SECURE_CLOCK:\r
 601         {\r
 602                 /* Check input parameters */\r
 603                 if (!is_allowed) {\r
 604                         DRM_CLIENT_EXCEPTION("Invalid Arg!!,is_allowed = %p",is_allowed);\r
 605                         return DRM_RETURN_INVALID_ARG;\r
 606                 }\r
 607 \r
 608                 /* Copy the input parameters to the Request structure */\r
 609                 req_data.fixed_data.action = action;\r
 610                 break;\r
 611         }\r
 612 \r
 613         default:\r
 614                 DRM_CLIENT_EXCEPTION("Invalid action type=%d",action);\r
 615                 return DRM_RETURN_INVALID_ARG;\r
 616         }\r
 617 \r
 618         /* Tell the server which API to be used */\r
 619         req_data.fixed_data.api_name = DRM_IS_ACTION_ALLOWED;\r
 620 \r
 621         /* Send Data to DRM server */\r
 622         /* Call the Client Communication API */\r
 623         if ((ret_comm = drm_client_comm(&req_data, &resp_data)) != 0) {\r
 624                 DRM_CLIENT_EXCEPTION("drm_client_comm error!!, ret_comm = %d", ret_comm);\r
 625                 result = DRM_RETURN_COMMUNICATION_ERROR;\r
 626                 goto ErrorExit;\r
 627         }\r
 628 \r
 629         /* Copy the response obtained from the server into the output parameter */\r
 630         if (resp_data.fixed_data.resp_result != 0) {\r
 631                 DRM_CLIENT_EXCEPTION("Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
 632                                 resp_data.fixed_data.resp_result);\r
 633                 *is_allowed = DRM_FALSE;\r
 634                 result = resp_data.fixed_data.resp_result;\r
 635                 goto ErrorExit;\r
 636         } else {\r
 637                 DRM_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x", resp_data.fixed_data.resp_result);\r
 638                 *is_allowed = resp_data.fixed_data.bool_val;\r
 639         }\r
 640 \r
 641 ErrorExit:\r
 642         if (result != DRM_RETURN_SUCCESS) {\r
 643                 DRM_CLIENT_EXCEPTION("Exit:failed!!, result = 0x%x", result);\r
 644         } else {\r
 645                 DRM_CLIENT_LOG("Exit:Success!!, result = 0x%x", result);\r
 646         }\r
 647         return result;\r
 648 }\r
 649 \r
 650 /**\r
 651  * An application can get the requested data from DRM.\r
 652  *\r
 653  * @param[in]   data_type       Data types as per enum drm_data_type_e.\r
 654  * @param[in]   input           Pointer to appropriate structure as per data_type.\r
 655  * @param[out]  output          Output data. Pointer to appropriate structure as\r
 656  *                                                      per data_type.\r
 657  *\r
 658  * @return              0 on success, else a negative error value\r
 659  * @retval              DRM_RETURN_SUCCESS on success\r
 660  * @retval              DRM_RETURN_INVALID_ARG if arguments are invalid\r
 661  * @retval              DRM_RETURN_COMMUNICATION_ERROR if socket error\r
 662  * @retval              DRM_RETURN_INTERNAL_ERROR if operation error\r
 663  * @remarks             Please typecast to appropriate data structures\r
 664  *                              as per data types.\r
 665  *\r
 666  *                              if data_type = DRM_DATA_TYPE_SECURE_CLOCK\r
 667  *                              then input type: input = NULL\r
 668  *                              and output type: output = pointer to struct\r
 669  *                              drm_secure_clock_data_s\r
 670  *\r
 671  *                              if data_type = DRM_DATA_TYPE_TRANSACTION_TRACKING_FLAG\r
 672  *                              then input type: input = NULL\r
 673  *                              and output type: output = pointer to int\r
 674  *\r
 675  *                              if data_type = DRM_DATA_TYPE_TRANSACTION_TRACKING_ID\r
 676  *                              then input type: input = pointer to file path (const char)\r
 677  *                              and output type: output = pointer to struct\r
 678  *                              drm_transaction_id_info_s\r
 679  *\r
 680  *                              if data_type = DRM_DATA_TYPE_DIVX_REGISTRATION_CODE\r
 681  *                              then input type: input = NULL\r
 682  *                              and output type: output = pointer to struct drm_code_info_s\r
 683  *\r
 684  *                              if data_type = DRM_DATA_TYPE_DIVX_DEREGISTRATION_CODE\r
 685  *                              then input type: input = NULL\r
 686  *                              and output type: output = pointer to struct drm_code_info_s\r
 687  *\r
 688  * @see\r
 689  * @since       0.1\r
 690  */\r
 691 EXPORT_API int drm_get_data(drm_data_type_e data_type, void *input, void *output)\r
 692 {\r
 693         DRM_CLIENT_LOG("Enter: data_type = %d, input = %p, output = %p",\r
 694                         data_type, input, output);\r
 695         /* Local Variables */\r
 696         drm_result_e result = DRM_RETURN_SUCCESS;\r
 697         drm_request_data_s req_data;\r
 698         drm_response_data_s resp_data;\r
 699         int ret_comm = 0;\r
 700         int ret_cpy = 0;\r
 701 \r
 702         /* memset the structures */\r
 703         memset(&req_data, 0x0, sizeof(drm_request_data_s));\r
 704         memset(&resp_data, 0x0, sizeof(drm_response_data_s));\r
 705 \r
 706         /* Check Input & Output Parameters and fill the Request data */\r
 707         switch (data_type) {\r
 708         case DRM_DATA_TYPE_SECURE_CLOCK:\r
 709         case DRM_DATA_TYPE_TRANSACTION_TRACKING_FLAG:\r
 710         case DRM_DATA_TYPE_DIVX_REGISTRATION_CODE:\r
 711         case DRM_DATA_TYPE_DIVX_DEREGISTRATION_CODE:\r
 712                 if (!output) {\r
 713                         DRM_CLIENT_EXCEPTION("Invalid arguments!!, output = %p", output);\r
 714                         return DRM_RETURN_INVALID_ARG;\r
 715                 }\r
 716                 break;\r
 717         case DRM_DATA_TYPE_TRANSACTION_TRACKING_ID: {\r
 718                 if (!input || ((char*)input)[0] == '\0' || !output) {\r
 719                         DRM_CLIENT_EXCEPTION("Invalid arguments!!, input = %p, output = %p",\r
 720                                         input, output);\r
 721                         return DRM_RETURN_INVALID_ARG;\r
 722                 }\r
 723 \r
 724                 /* Copy the input parameter to be sent as Request Data */\r
 725                 if ((ret_cpy = g_strlcpy(req_data.fixed_data.request_data,\r
 726                                 (const gchar*) input, DRM_MAX_LEN_FILEPATH))\r
 727                                 >= DRM_MAX_LEN_FILEPATH) {\r
 728                         DRM_CLIENT_EXCEPTION("file_path = %s, filepath_len = %d, ret_cpy = %d",\r
 729                                         (const char*)input, strlen(((const char*)input)), ret_cpy);\r
 730                         return DRM_RETURN_INVALID_ARG;\r
 731                 }\r
 732         }\r
 733                 break;\r
 734         default:\r
 735                 DRM_CLIENT_EXCEPTION("Invalid argument, data_type = %d", data_type);\r
 736                 return DRM_RETURN_INVALID_ARG;\r
 737         }\r
 738 \r
 739         DRM_CLIENT_LOG("data_type=%d input=%p output=%p", data_type, input, output);\r
 740 \r
 741         /* Fill other parameters to be sent */\r
 742         req_data.fixed_data.data_type = data_type;\r
 743 \r
 744         /* Tell the server which API to be used */\r
 745         req_data.fixed_data.api_name = DRM_GET_DATA;\r
 746 \r
 747         /* Send Data to DRM server */\r
 748         /* Call the Client Communication API */\r
 749         if ((ret_comm = drm_client_comm(&req_data, &resp_data)) != 0) {\r
 750                 DRM_CLIENT_EXCEPTION("drm_client_comm error!!, ret_comm = %d", ret_comm);\r
 751                 result = DRM_RETURN_COMMUNICATION_ERROR;\r
 752                 goto ErrorExit;\r
 753         }\r
 754 \r
 755         /* Copy the response obtained from the server into the output parameter */\r
 756         if (resp_data.fixed_data.resp_result != 0) {\r
 757                 DRM_CLIENT_EXCEPTION("Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
 758                                 resp_data.fixed_data.resp_result);\r
 759 \r
 760                 result = resp_data.fixed_data.resp_result;\r
 761                 goto ErrorExit;\r
 762         } else {\r
 763                 DRM_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x", resp_data.fixed_data.resp_result);\r
 764 \r
 765                 /* Store the response result to the output based on the request data type */\r
 766                 switch (data_type) {\r
 767 \r
 768                 case DRM_DATA_TYPE_SECURE_CLOCK: {\r
 769                         drm_secure_clock_data_s sec_clk_data = { 0, };\r
 770 \r
 771                         /* Copy from response data into local structure */\r
 772                         memcpy(&sec_clk_data, resp_data.fixed_data.response_data,\r
 773                                         sizeof(drm_secure_clock_data_s));\r
 774                         DRM_CLIENT_LOG("sec_clk_data.is_secure_clock_set = %d",\r
 775                                         sec_clk_data.is_secure_clock_set);\r
 776                         DRM_CLIENT_LOG("Year=%d,Month=%d,Day=%d,Hour=%d, minute=%d, Second=%d",\r
 777                                         sec_clk_data.secure_clock.tm_year,\r
 778                                         sec_clk_data.secure_clock.tm_mon,\r
 779                                         sec_clk_data.secure_clock.tm_mday,\r
 780                                         sec_clk_data.secure_clock.tm_hour,\r
 781                                         sec_clk_data.secure_clock.tm_min,\r
 782                                         sec_clk_data.secure_clock.tm_sec);\r
 783 \r
 784                         /* Now copy into output parameter */\r
 785                         memcpy(output, &sec_clk_data, sizeof(drm_secure_clock_data_s));\r
 786 \r
 787                 }\r
 788                         break;\r
 789 \r
 790                 case DRM_DATA_TYPE_TRANSACTION_TRACKING_FLAG: {\r
 791 \r
 792                         int transtrack_flag = 0;\r
 793 \r
 794                         /* Copy from response data into local structure */\r
 795                         memcpy(&transtrack_flag, resp_data.fixed_data.response_data, sizeof(int));\r
 796                         DRM_CLIENT_LOG("transtrack_flag = %d", transtrack_flag);\r
 797 \r
 798                         /* Now copy into output parameter */\r
 799                         memcpy(output, &transtrack_flag, sizeof(int));\r
 800 \r
 801                 }\r
 802                         break;\r
 803 \r
 804                 case DRM_DATA_TYPE_TRANSACTION_TRACKING_ID: {\r
 805                         drm_transaction_id_info_s transid_info;\r
 806                         memset(&transid_info,0,sizeof(transid_info));\r
 807 \r
 808                         /* Copy from response data into local structure */\r
 809                         memcpy(&transid_info, resp_data.fixed_data.response_data,\r
 810                                         sizeof(drm_transaction_id_info_s));\r
 811                         DRM_CLIENT_LOG("transid_info.tr_id = %s", transid_info.tr_id);\r
 812                         DRM_CLIENT_LOG("transid_info.tr_id_len = %d",\r
 813                                         transid_info.tr_id_len)\r
 814 \r
 815                         /* Now copy into output parameter */\r
 816                         memcpy(output, &transid_info, sizeof(drm_transaction_id_info_s));\r
 817 \r
 818                 }\r
 819                         break;\r
 820 \r
 821                 case DRM_DATA_TYPE_DIVX_REGISTRATION_CODE: {\r
 822 \r
 823                         drm_code_info_s registration_info;\r
 824                         memset(&registration_info,0,sizeof(registration_info));\r
 825 \r
 826                         /* Copy from response data into local structure */\r
 827                         memcpy(&registration_info, resp_data.fixed_data.response_data,\r
 828                                         sizeof(drm_code_info_s));\r
 829                         DRM_CLIENT_LOG("registration_info.code = %s",\r
 830                                         registration_info.code);\r
 831                         DRM_CLIENT_LOG("registration_info.code_len = %d",\r
 832                                         registration_info.code_len);\r
 833 \r
 834                         /* Now copy into output parameter */\r
 835                         memcpy(output, &registration_info, sizeof(drm_code_info_s));\r
 836 \r
 837                 }\r
 838                         break;\r
 839 \r
 840                 case DRM_DATA_TYPE_DIVX_DEREGISTRATION_CODE: {\r
 841 \r
 842                         drm_code_info_s deregis_info;\r
 843                         memset(&deregis_info,0,sizeof(deregis_info));\r
 844 \r
 845                         /* Copy from response data into local structure */\r
 846                         memcpy(&deregis_info, resp_data.fixed_data.response_data,\r
 847                                         sizeof(drm_code_info_s));\r
 848                         DRM_CLIENT_LOG("deregis_info.code = %s",\r
 849                                         deregis_info.code);\r
 850                         DRM_CLIENT_LOG("deregis_info.code_len = %d",\r
 851                                         deregis_info.code_len);\r
 852 \r
 853                         /* Now copy into output parameter */\r
 854                         memcpy(output, &deregis_info, sizeof(drm_code_info_s));\r
 855 \r
 856                 }\r
 857                         break;\r
 858 \r
 859                 }\r
 860 \r
 861         }\r
 862 \r
 863         /* Success */\r
 864         DRM_CLIENT_LOG("Exit:Success:result=0x%x",result);\r
 865         return result;\r
 866 \r
 867 ErrorExit:\r
 868         /* Failure */\r
 869         DRM_CLIENT_EXCEPTION("Exit:failed:result=0x%x",result);\r
 870         return result;\r
 871 }\r
 872 \r
 873 /**\r
 874  * An application can do particular request to DRM.\r
 875  *\r
 876  * @param[in]   request_type    Request types as per enum drm_request_type_e.\r
 877  * @param[in]   input                   Pointer to appropriate structure as per\r
 878  *                                                              request_type.\r
 879  * @param[out]  output                  Output data. Pointer to appropriate structure as\r
 880  *                                                              per request_type.\r
 881  *\r
 882  * @return              0 on success, else a negative error value\r
 883  * @retval              DRM_RETURN_SUCCESS on success\r
 884  * @retval              DRM_RETURN_INVALID_ARG if arguments are invalid\r
 885  * @retval              DRM_RETURN_COMMUNICATION_ERROR if socket error\r
 886  * @retval              DRM_RETURN_INTERNAL_ERROR if operation error\r
 887  * @remarks             Please typecast to appropriate data structures\r
 888  *                              as per data types.\r
 889  *\r
 890  *                              if request_type = DRM_REQUEST_TYPE_REGISTER_FILE\r
 891  *                              then input type: input = pointer to const char (file_path)\r
 892  *                              and output type: output = NULL\r
 893  *\r
 894  *                              if request_type = DRM_REQUEST_TYPE_UNREGISTER_FILE\r
 895  *                              then input type: input = pointer to struct drm_unregister_info_s\r
 896  *                              and output type: output = NULL\r
 897  *\r
 898  *                              if request_type = DRM_REQUEST_TYPE_UNREGISTER_ALL_FILES\r
 899  *                              then input type: input = NULL\r
 900  *                              and output type: output = NULL\r
 901  *\r
 902  *                              if request_type = DRM_REQUEST_TYPE_REGISTER_LICENSE\r
 903  *                              then input type: input = pointer to\r
 904  *                              struct drm_register_lic_info_s.\r
 905  *                              and output type: output = pointer to\r
 906  *                              struct drm_register_lic_resp_s.\r
 907  *\r
 908  *                              if request_type = DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL\r
 909  *                              then input type: input = pointer to struct drm_initiator_info_s\r
 910  *                              and output type: output = pointer to struct drm_web_server_resp_data_s\r
 911  *\r
 912  *                              if request_type = DRM_REQUEST_TYPE_SUBMIT_ROAP_MESSAGE\r
 913  *                              then input type: input = pointer to struct drm_submit_roap_message_info_s\r
 914  *                              and output type: output = NULL\r
 915  *\r
 916  *                              if request_type = DRM_REQUEST_TYPE_SUBMIT_ROAP_USER_CONSENT\r
 917  *                              then input type: input = pointer to struct drm_submit_roap_user_consent_info_s\r
 918  *                              and output type: output = NULL\r
 919  *\r
 920  *                              if request_type = DRM_REQUEST_TYPE_HTTP_USER_CANCEL\r
 921  *                              then input type: input = pointer to struct drm_http_user_cancel_info_s\r
 922  *                              and output type: output = NULL\r
 923  *\r
 924  *                              if request_type = DRM_REQUEST_TYPE_REGISTER_COPY_FILE\r
 925  *                              then input type: input = pointer to struct drm_register_copy_file_info_s\r
 926  *                              and output type: output = NULL\r
 927  *\r
 928  *                              if request_type = DRM_REQUEST_TYPE_REGISTER_MOVE_FILE\r
 929  *                              then input type: input = pointer to struct drm_register_copy_file_info_s\r
 930  *                              and output type: output = NULL\r
 931  *\r
 932  *                              if request_type = DRM_REQUEST_TYPE_INSERT_EXT_MEMORY\r
 933  *                              then input type: input = NULL\r
 934  *                              and output type: output = NULL\r
 935  *\r
 936  *                              if request_type = DRM_REQUEST_TYPE_EXTRACT_EXT_MEMORY\r
 937  *                              then input type: input = NULL\r
 938  *                              and output type: output = NULL\r
 939  *\r
 940  *                              if request_type = DRM_REQUEST_TYPE_REGISTER_SETAS\r
 941  *                              then input type: input = pointer to struct drm_register_setas_info_s\r
 942  *                              and output type: output = pointer to the struct drm_register_setas_resp_data_s\r
 943  *\r
 944  *                              if request_type = DRM_REQUEST_TYPE_UNREGISTER_SETAS\r
 945  *                              then input type: input = pointer to struct drm_unregister_setas_info_s\r
 946  *                              and output type: output = NULL\r
 947  *\r
 948  * @see\r
 949  * @since       0.1\r
 950  */\r
 951 EXPORT_API int drm_process_request(drm_request_type_e request_type,\r
 952                 void *input, void *output)\r
 953 {\r
 954         DRM_CLIENT_LOG("Enter: request_type = %d, input = %p, output = %p",\r
 955                         request_type, input, output);\r
 956         /* Local Variables */\r
 957         drm_result_e result = DRM_RETURN_SUCCESS;\r
 958         drm_request_data_s req_data;\r
 959         drm_response_data_s resp_data;\r
 960         int ret_comm = 0;\r
 961         int ret_cpy = 0;\r
 962 \r
 963         /* memset the structures */\r
 964         memset(&req_data, 0x0, sizeof(drm_request_data_s));\r
 965         memset(&resp_data, 0x0, sizeof(drm_response_data_s));\r
 966 \r
 967         DRM_CLIENT_LOG("request_type = %d", request_type);\r
 968 \r
 969         /* Check Input & Output Parameters */\r
 970         switch (request_type) {\r
 971         case DRM_REQUEST_TYPE_REGISTER_FILE: {\r
 972                 if (!input || ((char*)input)[0] == '\0') {\r
 973                         DRM_CLIENT_EXCEPTION("Invalid argument!!, input = %p", input);\r
 974                         return DRM_RETURN_INVALID_ARG;\r
 975                 } else {\r
 976                         /* Copy the input to Request Structure */\r
 977                         if ((ret_cpy = g_strlcpy(req_data.fixed_data.request_data,\r
 978                                         (const gchar*) input, DRM_MAX_LEN_FILEPATH))\r
 979                                         >= DRM_MAX_LEN_FILEPATH) {\r
 980                                 DRM_CLIENT_EXCEPTION("file_path = %s, filepath_len = %d, ret_cpy = %d",\r
 981                                                 (const char*)input, strlen(((const char*)input)), ret_cpy);\r
 982                                 return DRM_RETURN_INVALID_ARG;\r
 983                         }\r
 984                 }\r
 985         }\r
 986                 break;\r
 987 \r
 988         case DRM_REQUEST_TYPE_UNREGISTER_FILE: {\r
 989                 if (!input || ((char*)input)[0] == '\0') {\r
 990                         DRM_CLIENT_EXCEPTION("Invalid argument!!, input = %p", input);\r
 991                         return DRM_RETURN_INVALID_ARG;\r
 992                 } else {\r
 993                         /* Copy the input to Request Structure */\r
 994                         memcpy(req_data.fixed_data.request_data, input, sizeof(drm_unregister_info_s));\r
 995                 }\r
 996         }\r
 997                 break;\r
 998 \r
 999         case DRM_REQUEST_TYPE_UNREGISTER_ALL_FILES: {\r
1000                 DRM_CLIENT_LOG("No parameters required!");\r
1001         }\r
1002                 break;\r
1003 \r
1004         case DRM_REQUEST_TYPE_REGISTER_LICENSE: {\r
1005                 if (!input || ((char*)input)[0] == '\0' || !output) {\r
1006                         DRM_CLIENT_EXCEPTION("Invalid argument!!, input = %p, output = %p",\r
1007                                         input, output);\r
1008                         return DRM_RETURN_INVALID_ARG;\r
1009                 } else {\r
1010                         /* Copy the input to Request Structure */\r
1011                         memcpy(req_data.fixed_data.request_data, input,\r
1012                                         sizeof(drm_register_lic_info_s));\r
1013 \r
1014                 }\r
1015         }\r
1016                 break;\r
1017 \r
1018         case DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL: {\r
1019                 if (!input || ((char*)input)[0] == '\0' || !output) {\r
1020                         DRM_CLIENT_EXCEPTION("Invalid argument!!, input = %p, output = %p",\r
1021                                         input, output);\r
1022                         return DRM_RETURN_INVALID_ARG;\r
1023                 } else {\r
1024 \r
1025                         DRM_CLIENT_LOG("initiator_url[%s]", ((drm_initiator_info_s*)input)->initiator_url);\r
1026                         DRM_CLIENT_LOG("initiator_url_len[%u]", ((drm_initiator_info_s*)input)->initiator_url_len);\r
1027                         DRM_CLIENT_LOG("operation_callback.callback[%p]", ((drm_initiator_info_s*)input)->operation_callback.callback);\r
1028                         DRM_CLIENT_LOG("init_type[%d]", ((drm_initiator_info_s*)input)->init_type);\r
1029                         DRM_CLIENT_LOG("custom_data.app_id[%s]", ((drm_initiator_info_s*)input)->custom_data.app_id);\r
1030                         DRM_CLIENT_LOG("custom_data.user_guid[%s]", ((drm_initiator_info_s*)input)->custom_data.user_guid);\r
1031                         DRM_CLIENT_LOG("custom_data.device_id[%s]", ((drm_initiator_info_s*)input)->custom_data.device_id);\r
1032                         DRM_CLIENT_LOG("custom_data.order_id[%s]", ((drm_initiator_info_s*)input)->custom_data.order_id);\r
1033                         DRM_CLIENT_LOG("custom_data.service_id[%s]", ((drm_initiator_info_s*)input)->custom_data.service_id);\r
1034                         DRM_CLIENT_LOG("custom_data.account_id[%s]", ((drm_initiator_info_s*)input)->custom_data.account_id);\r
1035 \r
1036                         /* Copy the input to Request Structure */\r
1037                         memcpy(req_data.fixed_data.request_data, input,\r
1038                                         sizeof(drm_initiator_info_s));\r
1039                 }\r
1040         }\r
1041                 break;\r
1042 \r
1043         case DRM_REQUEST_TYPE_SUBMIT_ROAP_MESSAGE: {\r
1044 \r
1045                 if (!input\r
1046                         || (!((drm_submit_roap_message_info_s*) input)->buffer)\r
1047                         || (((drm_submit_roap_message_info_s*) input)->buffer[0] == '\0')\r
1048                         || (((drm_submit_roap_message_info_s*) input)->buff_size == 0)) {\r
1049                         DRM_CLIENT_EXCEPTION("Invalid argument!!, input = %p", input);\r
1050                         return DRM_RETURN_INVALID_ARG;\r
1051                 } else {\r
1052 \r
1053                         /* Copy the input to Request Structure */\r
1054                         memcpy(req_data.fixed_data.request_data, input,\r
1055                                         sizeof(drm_submit_roap_message_info_s));\r
1056 \r
1057                         /* Number of additional data items to be sent */\r
1058                         if ((((drm_submit_roap_message_info_s*) input)->app_session_data.pData)\r
1059                                 && (((drm_submit_roap_message_info_s*) input)->app_session_data.size_pData != 0)) {\r
1060                                 req_data.fixed_data.num_data_items = 2;\r
1061                         } else {\r
1062                                 req_data.fixed_data.num_data_items = 1;\r
1063                         }\r
1064 \r
1065                         /* Fill details pertaining to additional pointers to be sent */\r
1066                         req_data.fixed_data.data_length[0] =\r
1067                                         ((drm_submit_roap_message_info_s*) input)->buff_size;\r
1068 \r
1069                         /* Allocate memory for data items */\r
1070                         req_data.data_items[0] = (char*) malloc(\r
1071                                         req_data.fixed_data.data_length[0]);\r
1072                         if (!req_data.data_items[0]) {\r
1073                                 DRM_CLIENT_EXCEPTION("Memory Allocation Error!, Buf = %p",\r
1074                                                 req_data.data_items[0]);\r
1075                                 result = DRM_RETURN_INSUFFICIENT_MEMORY;\r
1076                                 goto ErrorExit;\r
1077                         }\r
1078 \r
1079                         /* Copy the buffer into data items */\r
1080                         memcpy(req_data.data_items[0],\r
1081                                         ((drm_submit_roap_message_info_s*) input)->buffer,\r
1082                                         ((drm_submit_roap_message_info_s*) input)->buff_size);\r
1083 \r
1084                         if (2 == req_data.fixed_data.num_data_items) {\r
1085                                 req_data.fixed_data.data_length[1] =\r
1086                                                 ((drm_submit_roap_message_info_s*) input)->app_session_data.size_pData;\r
1087 \r
1088                                 req_data.data_items[1] = (char*) malloc(\r
1089                                                 req_data.fixed_data.data_length[1]);\r
1090                                 if (!req_data.data_items[1]) {\r
1091                                         DRM_CLIENT_EXCEPTION("Memory Allocation Error!, Buf = %p",\r
1092                                                         req_data.data_items[1]);\r
1093                                         result = DRM_RETURN_INSUFFICIENT_MEMORY;\r
1094                                         goto ErrorExit;\r
1095                                 }\r
1096 \r
1097                                 /* Copy the Additional data */\r
1098                                 memcpy( req_data.data_items[1],\r
1099                                                 ((drm_submit_roap_message_info_s*) input)->app_session_data.pData,\r
1100                                                 ((drm_submit_roap_message_info_s*) input)->app_session_data.size_pData);\r
1101                         }\r
1102                 }\r
1103 \r
1104         }\r
1105                 break;\r
1106 \r
1107         case DRM_REQUEST_TYPE_SUBMIT_ROAP_USER_CONSENT: {\r
1108 \r
1109                 if (!input\r
1110                         || (!((drm_submit_roap_user_consent_info_s*) input)->agentdata)\r
1111                         || (((drm_submit_roap_user_consent_info_s*) input)->size_agentdata == 0)) {\r
1112                         DRM_CLIENT_EXCEPTION("Invalid argument!!, input = %p", input);\r
1113                         return DRM_RETURN_INVALID_ARG;\r
1114                 } else {\r
1115 \r
1116                         /* Copy the input to Request Structure */\r
1117                         memcpy(req_data.fixed_data.request_data, input,\r
1118                                         sizeof(drm_submit_roap_user_consent_info_s));\r
1119 \r
1120                         /* Number of additional data items to be sent */\r
1121                         req_data.fixed_data.num_data_items = 1;\r
1122 \r
1123                         /* Fill details pertaining to additional pointers to be sent */\r
1124                         req_data.fixed_data.data_length[0] =\r
1125                                         ((drm_submit_roap_user_consent_info_s*) input)->size_agentdata;\r
1126 \r
1127                         /* Allocate memory for data items */\r
1128                         req_data.data_items[0] = (char*) malloc(\r
1129                                         req_data.fixed_data.data_length[0]);\r
1130                         if (!req_data.data_items[0]) {\r
1131                                 DRM_CLIENT_EXCEPTION("Memory Allocation Error!, Buf = %p",\r
1132                                                 req_data.data_items[0]);\r
1133                                 result = DRM_RETURN_INSUFFICIENT_MEMORY;\r
1134                                 goto ErrorExit;\r
1135                         }\r
1136 \r
1137                         /* Copy the buffer into data items */\r
1138                         memcpy(req_data.data_items[0],\r
1139                                    ((drm_submit_roap_user_consent_info_s*) input)->agentdata,\r
1140                                    ((drm_submit_roap_user_consent_info_s*) input)->size_agentdata);\r
1141                 }\r
1142 \r
1143         }\r
1144                 break;\r
1145 \r
1146         case DRM_REQUEST_TYPE_HTTP_USER_CANCEL: {\r
1147 \r
1148                 if (!input\r
1149                         || (!((drm_http_user_cancel_info_s*) input)->app_session_data)\r
1150                         || (((drm_http_user_cancel_info_s*) input)->size_app_session_data == 0)) {\r
1151                         DRM_CLIENT_EXCEPTION("Invalid argument!!, input = %p", input);\r
1152                         return DRM_RETURN_INVALID_ARG;\r
1153                 } else {\r
1154 \r
1155                         /* Copy the input to Request Structure */\r
1156                         memcpy(req_data.fixed_data.request_data, input,\r
1157                                         sizeof(drm_http_user_cancel_info_s));\r
1158 \r
1159                         /* Number of additional data items to be sent */\r
1160                         req_data.fixed_data.num_data_items = 1;\r
1161 \r
1162                         /* Fill details pertaining to additional pointers to be sent */\r
1163                         req_data.fixed_data.data_length[0] =\r
1164                                         ((drm_http_user_cancel_info_s*) input)->size_app_session_data;\r
1165 \r
1166                         /* Allocate memory for data items */\r
1167                         req_data.data_items[0] = (char*) malloc(\r
1168                                         req_data.fixed_data.data_length[0]);\r
1169                         if (!req_data.data_items[0]) {\r
1170                                 DRM_CLIENT_EXCEPTION("Memory Allocation Error!, Buf = %p",\r
1171                                                 req_data.data_items[0]);\r
1172                                 result = DRM_RETURN_INSUFFICIENT_MEMORY;\r
1173                                 goto ErrorExit;\r
1174                         }\r
1175 \r
1176                         /* Copy the buffer into data items */\r
1177                         memcpy(req_data.data_items[0],\r
1178                                         ((drm_http_user_cancel_info_s*) input)->app_session_data,\r
1179                                         ((drm_http_user_cancel_info_s*) input)->size_app_session_data);\r
1180 \r
1181                 }\r
1182 \r
1183         }\r
1184                 break;\r
1185 \r
1186         case DRM_REQUEST_TYPE_REGISTER_COPY_FILE: {\r
1187 \r
1188                 if (!input\r
1189                                 || (((drm_register_copy_file_info_s*) input)->src_file_path[0] == '\0')\r
1190                                 || (((drm_register_copy_file_info_s*) input)->dest_file_path[0] == '\0')) {\r
1191                         DRM_CLIENT_EXCEPTION("Invalid argument!!, input = %p", input);\r
1192                         return DRM_RETURN_INVALID_ARG;\r
1193                 } else {\r
1194 \r
1195                         /* Copy the input to Request Structure */\r
1196                         memcpy(req_data.fixed_data.request_data, input,\r
1197                                         sizeof(drm_register_copy_file_info_s));\r
1198                 }\r
1199         }\r
1200                 break;\r
1201 \r
1202         case DRM_REQUEST_TYPE_REGISTER_MOVE_FILE: {\r
1203 \r
1204                 if (!input\r
1205                                 || (((drm_register_move_file_info_s*) input)->src_file_path[0] == '\0')\r
1206                                 || (((drm_register_move_file_info_s*) input)->dest_file_path[0] == '\0')) {\r
1207                         DRM_CLIENT_EXCEPTION("Invalid argument!!, input = %p", input);\r
1208                         return DRM_RETURN_INVALID_ARG;\r
1209                 } else {\r
1210 \r
1211                         /* Copy the input to Request Structure */\r
1212                         memcpy(req_data.fixed_data.request_data, input,\r
1213                                         sizeof(drm_register_move_file_info_s));\r
1214                 }\r
1215         }\r
1216                 break;\r
1217 \r
1218         case DRM_REQUEST_TYPE_INSERT_EXT_MEMORY:\r
1219         case DRM_REQUEST_TYPE_EXTRACT_EXT_MEMORY:\r
1220                 DRM_CLIENT_LOG("No parameters to check!!");\r
1221                 break;\r
1222 \r
1223         case DRM_REQUEST_TYPE_REGISTER_SETAS: {\r
1224 \r
1225                 if (!input\r
1226                         || (((drm_register_setas_info_s*) input)->file_path[0] == '\0')) {\r
1227                         DRM_CLIENT_EXCEPTION("Invalid argument!!, input = %p", input);\r
1228                         return DRM_RETURN_INVALID_ARG;\r
1229                 } else {\r
1230                         /* Copy the input to Request Structure */\r
1231                         memcpy(req_data.fixed_data.request_data, input,\r
1232                                         sizeof(drm_register_setas_info_s));\r
1233                 }\r
1234 \r
1235         }\r
1236                 break;\r
1237 \r
1238         case DRM_REQUEST_TYPE_UNREGISTER_SETAS: {\r
1239 \r
1240                 if (!input\r
1241                                 || (((drm_unregister_setas_info_s*) input)->file_path[0] == '\0')) {\r
1242                         DRM_CLIENT_EXCEPTION("Invalid argument!!, input = %p", input);\r
1243                         return DRM_RETURN_INVALID_ARG;\r
1244                 } else {\r
1245                         /* Copy the input to Request Structure */\r
1246                         memcpy(req_data.fixed_data.request_data, input,\r
1247                                         sizeof(drm_unregister_setas_info_s));\r
1248                 }\r
1249         }\r
1250                 break;\r
1251 \r
1252         default:\r
1253                 DRM_CLIENT_EXCEPTION("Invalid Argument! request_type = %d",\r
1254                                 request_type);\r
1255                 return DRM_RETURN_INVALID_ARG;\r
1256         }\r
1257 \r
1258         DRM_CLIENT_LOG("input=%p output=%p", input, output);\r
1259 \r
1260         /* Fill other parameters to be sent */\r
1261         req_data.fixed_data.request_type = request_type;\r
1262 \r
1263         /* Tell the server which API to be used */\r
1264         req_data.fixed_data.api_name = DRM_PROCESS_REQUEST;\r
1265 \r
1266         /* Send Data to DRM server */\r
1267         /* Call the Client Communication API */\r
1268         if ((ret_comm = drm_client_comm(&req_data, &resp_data)) != 0) {\r
1269                 DRM_CLIENT_EXCEPTION("drm_client_comm error!!, ret_comm = %d", ret_comm);\r
1270                 result = DRM_RETURN_COMMUNICATION_ERROR;\r
1271                 goto ErrorExit;\r
1272         }\r
1273 \r
1274         /* Copy the response obtained from the server into the output parameter */\r
1275         if (resp_data.fixed_data.resp_result != 0) {\r
1276                 DRM_CLIENT_EXCEPTION("Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
1277                                 resp_data.fixed_data.resp_result);\r
1278 \r
1279                 result = resp_data.fixed_data.resp_result;\r
1280                 goto ErrorExit;\r
1281         } else {\r
1282                 DRM_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x", resp_data.fixed_data.resp_result);\r
1283 \r
1284                 /* Store the response result to the output based on the Request type */\r
1285                 switch (request_type) {\r
1286                 case DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL: {\r
1287 \r
1288                         drm_web_server_resp_data_s ws_resp_data;\r
1289                         memset(&ws_resp_data,0,sizeof(ws_resp_data));\r
1290                         /* Copy from response data into local structure */\r
1291                         memcpy(&ws_resp_data, resp_data.fixed_data.response_data,\r
1292                                         sizeof(drm_web_server_resp_data_s));\r
1293                         DRM_CLIENT_LOG("ws_resp_data.fixed_data.content_url = %s",\r
1294                                         ws_resp_data.content_url);\r
1295                         DRM_CLIENT_LOG("ws_resp_data.result_code = 0x%x",\r
1296                                         ws_resp_data.result_code);\r
1297 \r
1298                         /* Now copy into output parameter */\r
1299                         memcpy(output, &ws_resp_data, sizeof(drm_web_server_resp_data_s));\r
1300 \r
1301                 }\r
1302                         break;\r
1303 \r
1304                 case DRM_REQUEST_TYPE_REGISTER_LICENSE: {\r
1305 \r
1306                         drm_register_lic_resp_s lic_resp;\r
1307                         memset(&lic_resp,0,sizeof(lic_resp));\r
1308 \r
1309                         /* Copy from response data into local structure */\r
1310                         memcpy(&lic_resp, resp_data.fixed_data.response_data,\r
1311                                         sizeof(drm_register_lic_resp_s));\r
1312                         DRM_CLIENT_LOG("lic_resp.cid = %s", lic_resp.cid);\r
1313 \r
1314                         /* Now copy into output parameter */\r
1315                         memcpy(output, &lic_resp, sizeof(drm_register_lic_resp_s));\r
1316 \r
1317                 }\r
1318                         break;\r
1319 \r
1320                 case DRM_REQUEST_TYPE_REGISTER_SETAS: {\r
1321 \r
1322                         DRM_CLIENT_LOG("Register Setas Successful");\r
1323                         drm_register_setas_resp_data_s setas_resp = { 0, };\r
1324 \r
1325                         /* Copy from response data into local structure */\r
1326                         memcpy(&setas_resp, resp_data.fixed_data.response_data,\r
1327                         sizeof(drm_register_setas_resp_data_s));\r
1328 \r
1329                         /* Now copy into output parameter */\r
1330                         memcpy(output, &setas_resp, sizeof(drm_register_setas_resp_data_s));\r
1331                 }\r
1332                         break;\r
1333                 case DRM_REQUEST_TYPE_REGISTER_FILE:\r
1334                 case DRM_REQUEST_TYPE_UNREGISTER_FILE:\r
1335                 case DRM_REQUEST_TYPE_UNREGISTER_ALL_FILES:\r
1336                 case DRM_REQUEST_TYPE_SUBMIT_ROAP_MESSAGE:\r
1337                 case DRM_REQUEST_TYPE_SUBMIT_ROAP_USER_CONSENT:\r
1338                 case DRM_REQUEST_TYPE_HTTP_USER_CANCEL:\r
1339                 case DRM_REQUEST_TYPE_REGISTER_COPY_FILE:\r
1340                 case DRM_REQUEST_TYPE_REGISTER_MOVE_FILE:\r
1341                 case DRM_REQUEST_TYPE_INSERT_EXT_MEMORY:\r
1342                 case DRM_REQUEST_TYPE_EXTRACT_EXT_MEMORY:\r
1343                 case DRM_REQUEST_TYPE_UNREGISTER_SETAS:\r
1344                         DRM_CLIENT_LOG("No output parameters to be handled!!");\r
1345                         break;\r
1346 \r
1347                 }\r
1348         }\r
1349 \r
1350 \r
1351 ErrorExit:\r
1352 \r
1353         /* Free Request Data memory */\r
1354         for (unsigned int i = 0; i < req_data.fixed_data.num_data_items; i++) {\r
1355                 if (req_data.data_items[i])\r
1356                         free(req_data.data_items[i]);\r
1357         }\r
1358 \r
1359         /* Free Response Data memory */\r
1360         for (unsigned int i = 0; i < resp_data.fixed_data.num_data_items; i++) {\r
1361                 if (resp_data.data_items[i])\r
1362                         free(resp_data.data_items[i]);\r
1363         }\r
1364 \r
1365         DRM_CLIENT_LOG("Result[0x%x]", result);\r
1366 \r
1367         return result;\r
1368 }\r
1369 \r
1370 /**\r
1371  *  Private function\r
1372  *\r
1373  *\r
1374  * @param[in]   file_path               Specifies the pointer points a DRM file path.\r
1375  * @return              This function returns DRM file type.\r
1376  * @remarks\r
1377  * @see\r
1378  * @since       0.1\r
1379  */\r
1380 static drm_file_type_e _drm_client_get_file_type(const char* file_path)\r
1381 {\r
1382         char *p = NULL;\r
1383         p = (char *) strrchr(file_path, '.');\r
1384         if (!p) {\r
1385                 DRM_CLIENT_EXCEPTION("Invalid file_path!, file_path = %s", file_path);\r
1386                 return DRM_TYPE_UNDEFINED;\r
1387         }\r
1388 \r
1389         DRM_CLIENT_LOG("file_path=[%s], p=[0x%x]", file_path, p);\r
1390 \r
1391         if (p && ((strncasecmp(p, ".dcf", 4) == 0))) {\r
1392 \r
1393                 DRM_CLIENT_LOG("OMA DRM V1 File: file_path=%s p=%s", file_path, p);\r
1394                 return DRM_TYPE_OMA_V1;\r
1395 \r
1396         } else if (p &&  ((strncasecmp(p, ".odf", 4) == 0)\r
1397                         || (strncasecmp(p, ".o4a", 4) == 0)\r
1398                         || (strncasecmp(p, ".o4v", 4) == 0))) {\r
1399 \r
1400                 DRM_CLIENT_LOG("OMA DRM V2 File: file_path=%s p=%s", file_path, p);\r
1401                 return DRM_TYPE_OMA_V2;\r
1402 \r
1403         } else if ((p && ((strncasecmp(p, ".pya", 4) == 0)\r
1404                         || (strncasecmp(p, ".pyv", 4) == 0)))) {\r
1405 \r
1406                 DRM_CLIENT_LOG("PlayReady File: file_path=%s p=%s", file_path, p);\r
1407                 return DRM_TYPE_PLAYREADY;\r
1408 \r
1409         } else if (p && ((strncasecmp(p, ".eny", 4) == 0)\r
1410                         || (strncasecmp(p, ".pye", 4) == 0)\r
1411                         || (strncasecmp(p, ".jue", 4) == 0)))   {\r
1412 \r
1413                 DRM_CLIENT_LOG("PlayReady Envelope File: file_path=%s p=%s", file_path, p);\r
1414                 return DRM_TYPE_PLAYREADY_ENVELOPE;\r
1415 \r
1416         } else if (p && ((strncasecmp(p, ".avi", 4) == 0)\r
1417                         || (strncasecmp(p, ".divx", 5) == 0))) {\r
1418 \r
1419                 DRM_CLIENT_LOG("DivX DRM File: file_path=%s p=%s", file_path, p);\r
1420                 return DRM_TYPE_DIVX;\r
1421 \r
1422         } else {\r
1423                 DRM_CLIENT_LOG("NON DRM file=%s", file_path);\r
1424                 return DRM_TYPE_UNDEFINED;\r
1425         }\r
1426 }\r