service/drm_trusted_client.cpp

   1 /*\r
   2  * drm-trusted-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  * @file                drm_trusted_client.cpp\r
  27  * @brief       DRM Trusted Client API defintions.\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 API Definitions.\r
  32  */\r
  33 \r
  34 #include <stdlib.h>\r
  35 #include <string.h>\r
  36 #include <malloc.h>\r
  37 \r
  38 #include "drm_trusted_client.h"\r
  39 #include "drm_trusted_client_ipc.h"\r
  40 #include "drm_trusted_client_log.h"\r
  41 \r
  42 #ifndef EXPORT_API\r
  43 #define EXPORT_API __attribute__((visibility("default")))\r
  44 #endif\r
  45 \r
  46 /**\r
  47  * An application can do particular request to DRM.\r
  48  *\r
  49  * @param[in]   request_type    Request types as per enum drm_trusted_request_type_e.\r
  50  * @param[in]   input                   Pointer to appropriate structure as per\r
  51  *                                                              request_type.\r
  52  * @param[out]  output                  Output data. Pointer to appropriate structure as\r
  53  *                                                              per request_type.\r
  54  *\r
  55  * @return              0 on success, else a negative error value\r
  56  * @retval              DRM_TRUSTED_RETURN_SUCCESS on success\r
  57  * @retval              DRM_TRUSTED_RETURN_INVALID_ARG if arguments are invalid\r
  58  * @retval              DRM_TRUSTED_RETURN_COMMUNICATION_ERROR if socket error\r
  59  * @retval              DRM_TRUSTED_RETURN_INTERNAL_ERROR if operation error\r
  60  * @remarks             Please typecast to appropriate data structures\r
  61  *                              as per data types.\r
  62  *\r
  63  *                              if request_type = DRM_TRUSTED_REQ_TYPE_UPDATE_SECURE_CLK\r
  64  *                              then input type: input = pointer to struct drm_trusted_update_sec_clk_info_s\r
  65  *                              and output type: output = NULL\r
  66  *\r
  67  *                              if request_type = DRM_TRUSTED_REQ_TYPE_SET_SECURE_CLK\r
  68  *                              then input type: input = pointer to struct drm_trusted_set_sec_clk_info_s\r
  69  *                              and output type: output = NULL\r
  70  *\r
  71  *                              if request_type = DRM_TRUSTED_REQ_TYPE_SET_TRANSACTION_TRACKING\r
  72  *                              then input type: input = pointer to struct drm_trusted_set_transaction_trk_info_s\r
  73  *                              and output type: output = NULL\r
  74  *\r
  75  *                              if request_type = DRM_TRUSTED_REQ_TYPE_MASTER_RESET\r
  76  *                              then input type: input = NULL\r
  77  *                              and output type: output = NULL\r
  78  *\r
  79  *                              if request_type = DRM_TRUSTED_REQ_TYPE_VERIFY_ENCRYPTED_CERT\r
  80  *                              then input type: input = NULL\r
  81  *                              and output type: output = NULL\r
  82  *\r
  83  *                              if request_type = DRM_TRUSTED_REQ_TYPE_CREATE_INIT_DB\r
  84  *                              then input type: input = NULL\r
  85  *                              and output type: output = NULL\r
  86  *\r
  87  *                              if request_type = DRM_TRUSTED_REQ_TYPE_REINSTALL_CERT\r
  88  *                              then input type: input = NULL\r
  89  *                              and output type: output = NULL\r
  90  *\r
  91  *                              if request_type = DRM_TRUSTED_REQ_TYPE_REMOVE_RO\r
  92  *                              then input type: input = pointer to struct drm_trusted_remove_ro_info_s\r
  93  *                              and output type: output = NULL\r
  94  *\r
  95  *                              if request_type = DRM_TRUSTED_REQ_TYPE_REMOVE_ALL_RO\r
  96  *                              then input type: input = NULL\r
  97  *                              and output type: output = NULL\r
  98  *\r
  99  *                              if request_type = DRM_TRUSTED_REQ_TYPE_GO_RIGHTS_URL\r
 100  *                              then input type: input = pointer to struct drm_trusted_go_rights_url_info_s\r
 101  *                              and output type: output = NULL\r
 102  *\r
 103  *                              if request_type = DRM_TRUSTED_REQ_TYPE_PD_SET_DOWNLOAD_COMPLETE\r
 104  *                              then input type: input = pointer to struct drm_trusted_pd_set_dld_comp_info_s\r
 105  *                              and output type: output = NULL\r
 106  *\r
 107  *                              if request_type = DRM_TRUSTED_REQ_TYPE_PD_GET_PARSE_STATUS_INFO\r
 108  *                              then input type: input = pointer to struct drm_trusted_pd_parse_status_info_s\r
 109  *                              and output type: output = pointer to struct drm_trusted_pd_parse_status_resp_s\r
 110  *\r
 111  *                              if request_type = DRM_TRUSTED_REQ_TYPE_PIFF_GET_LICENSE\r
 112  *                              then input type: input = pointer to struct drm_trusted_piff_get_license_info_s\r
 113  *                              and output type: output = NULL\r
 114  *\r
 115  *                              if request_type = DRM_TRUSTED_REQ_TYPE_SAPPS_DECRYPT_PACKAGE\r
 116  *                              then input type: input = pointer to struct drm_trusted_sapps_decrypt_package_info_s\r
 117  *                              and output type: output = NULL\r
 118  *\r
 119  *                              if request_type = DRM_TRUSTED_REQ_TYPE_SAPPS_CONSUME_LICENSE\r
 120  *                              then input type: input = pointer to struct drm_trusted_sapps_consume_license_info_s\r
 121  *                              and output type: output = NULL\r
 122  *\r
 123  *                              if request_type = DRM_TRUSTED_REQ_TYPE_SAPPS_GENERATE_PURCHASE_REQUEST\r
 124  *                              then input type: input = pointer to struct drm_trusted_sapps_gen_purchase_req_info_s\r
 125  *                              and output type: output = pointer to struct drm_trusted_sapps_gen_purchase_req_resp_s\r
 126  *\r
 127  *                              if request_type = DRM_TRUSTED_REQ_TYPE_SAPPS_GENERATE_LICENSE_REQUEST\r
 128  *                              then input type: input = pointer to struct drm_trusted_sapps_gen_license_req_info_s\r
 129  *                              and output type: output = pointer to struct drm_trusted_sapps_gen_license_req_resp_s\r
 130  *\r
 131  *\r
 132  * @see\r
 133  * @since       0.1\r
 134  */\r
 135 \r
 136 EXPORT_API int drm_trusted_handle_request(drm_trusted_request_type_e request_type,\r
 137                 void *input, void *output)\r
 138 {\r
 139         /* Local Variables */\r
 140         drm_trusted_result_e result = DRM_TRUSTED_RETURN_SUCCESS;\r
 141         drm_trusted_request_data_s req_data;\r
 142         drm_trusted_response_data_s resp_data;\r
 143         int ret_comm = 0;\r
 144         int retval = 0;\r
 145 \r
 146         /* memset the structures */\r
 147         memset(&req_data, 0x0, sizeof(drm_trusted_request_data_s));\r
 148         memset(&resp_data, 0x0, sizeof(drm_trusted_response_data_s));\r
 149 \r
 150         DRM_TRUSTED_CLIENT_LOG("request_type = %d", request_type);\r
 151 \r
 152         /* Check Input & Output Parameters */\r
 153         switch (request_type) {\r
 154 \r
 155         case DRM_TRUSTED_REQ_TYPE_UPDATE_SECURE_CLK: {\r
 156                 if (!input) {\r
 157                         DRM_TRUSTED_CLIENT_EXCEPTION("Invalid argument!!, input = %p",\r
 158                                         input);\r
 159                         return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 160                 } else {\r
 161                         /* Copy the input to Request Structure */\r
 162                         memcpy(req_data.fixed_data.request_data, input,\r
 163                                         sizeof(drm_trusted_update_sec_clk_info_s));\r
 164                 }\r
 165         }\r
 166                 break;\r
 167 \r
 168         case DRM_TRUSTED_REQ_TYPE_SET_SECURE_CLK: {\r
 169                 if (!input) {\r
 170                         DRM_TRUSTED_CLIENT_EXCEPTION("Invalid argument!!, input = %p",\r
 171                                         input);\r
 172                         return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 173                 } else {\r
 174                         /* Copy the input to Request Structure */\r
 175                         memcpy(req_data.fixed_data.request_data, input,\r
 176                                         sizeof(drm_trusted_set_sec_clk_info_s));\r
 177 \r
 178                 }\r
 179         }\r
 180                 break;\r
 181 \r
 182         case DRM_TRUSTED_REQ_TYPE_SET_TRANSACTION_TRACKING: {\r
 183                 if (!input) {\r
 184                         DRM_TRUSTED_CLIENT_EXCEPTION("Invalid argument!!, input = %p",\r
 185                                         input);\r
 186                         return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 187                 } else {\r
 188 \r
 189                         /* Copy the input to Request Structure */\r
 190                         memcpy(req_data.fixed_data.request_data, input,\r
 191                                         sizeof(drm_trusted_set_transaction_trk_info_s));\r
 192 \r
 193                 }\r
 194         }\r
 195                 break;\r
 196 \r
 197         case DRM_TRUSTED_REQ_TYPE_MASTER_RESET:\r
 198         case DRM_TRUSTED_REQ_TYPE_VERIFY_ENCRYPTED_CERT:\r
 199         case DRM_TRUSTED_REQ_TYPE_CREATE_INIT_DB:\r
 200         case DRM_TRUSTED_REQ_TYPE_REINSTALL_CERT:\r
 201         case DRM_TRUSTED_REQ_TYPE_REMOVE_ALL_RO: {\r
 202                 DRM_TRUSTED_CLIENT_LOG("No parameters to be read!!");\r
 203         }\r
 204                 break;\r
 205 \r
 206         case DRM_TRUSTED_REQ_TYPE_REMOVE_RO: {\r
 207 \r
 208                 if (!input || (((drm_trusted_remove_ro_info_s*)input)->filePath[0]) == '\0') {\r
 209                         DRM_TRUSTED_CLIENT_EXCEPTION("Invalid argument!!, input = %p, filepath = %s",\r
 210                                         input, (!input) ? "":((drm_trusted_remove_ro_info_s*)input)->filePath);\r
 211                         return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 212                 } else {\r
 213 \r
 214                         /* Copy the input to Request Structure */\r
 215                         memcpy(req_data.fixed_data.request_data, input,\r
 216                                         sizeof(drm_trusted_remove_ro_info_s));\r
 217                 }\r
 218 \r
 219         }\r
 220                 break;\r
 221 \r
 222         case DRM_TRUSTED_REQ_TYPE_GO_RIGHTS_URL: {\r
 223 \r
 224                 if (!input || (((drm_trusted_go_rights_url_info_s*)input)->file_path[0]) == '\0') {\r
 225                         DRM_TRUSTED_CLIENT_EXCEPTION("Invalid argument!!, input = %p, filepath = %s",\r
 226                                         input, (!input) ? "":((drm_trusted_go_rights_url_info_s*)input)->file_path);\r
 227                         return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 228                 } else {\r
 229 \r
 230                         /* Copy the input to request Structure */\r
 231                         memcpy(req_data.fixed_data.request_data, input,\r
 232                                         sizeof(drm_trusted_go_rights_url_info_s));\r
 233 \r
 234                         if (((drm_trusted_go_rights_url_info_s*) input)->app_session_data.pData\r
 235                                 && ((drm_trusted_go_rights_url_info_s*) input)->app_session_data.size_pData     != 0) {\r
 236 \r
 237                                 req_data.fixed_data.num_data_items = 1;\r
 238 \r
 239                                 /* Fill details pertaining to additional pointers to be sent */\r
 240                                 req_data.fixed_data.data_length[0] =\r
 241                                                 ((drm_trusted_go_rights_url_info_s*) input)->app_session_data.size_pData;\r
 242 \r
 243                                 /* Allocate memory for data items */\r
 244                                 req_data.data_items[0] = (char*) malloc(\r
 245                                                 req_data.fixed_data.data_length[0]);\r
 246                                 if (!req_data.data_items[0]) {\r
 247                                         DRM_TRUSTED_CLIENT_EXCEPTION("Memory Allocation Error!, Buf = %p",\r
 248                                                         req_data.data_items[0]);\r
 249                                         result = DRM_TRUSTED_RETURN_INSUFFICIENT_MEMORY;\r
 250                                         goto ErrorExit;\r
 251                                 }\r
 252 \r
 253                                 /* Copy the buffer into data items */\r
 254                                 memcpy(req_data.data_items[0],\r
 255                                                 ((drm_trusted_go_rights_url_info_s*) input)->app_session_data.pData,\r
 256                                                 ((drm_trusted_go_rights_url_info_s*) input)->app_session_data.size_pData);\r
 257 \r
 258                         }\r
 259                 }\r
 260         }\r
 261                 break;\r
 262 \r
 263         case DRM_TRUSTED_REQ_TYPE_PD_SET_DOWNLOAD_COMPLETE: {\r
 264 \r
 265                 if (!input\r
 266                         || (!((drm_trusted_pd_set_dld_comp_info_s*) (input))->pdHandle)) {\r
 267                         DRM_TRUSTED_CLIENT_EXCEPTION(\r
 268                                         "Invalid argument!!, input = %p, pdHandle = %p",\r
 269                                         input, (!input) ? NULL:((drm_trusted_pd_set_dld_comp_info_s*)(input))->pdHandle);\r
 270                         return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 271                 } else {\r
 272 \r
 273                         /* Copy the input to Request Structure */\r
 274                         req_data.fixed_data.pHandle =\r
 275                                         ((drm_trusted_pd_set_dld_comp_info_s*) (input))->pdHandle;\r
 276                 }\r
 277 \r
 278         }\r
 279                 break;\r
 280 \r
 281         case DRM_TRUSTED_REQ_TYPE_PD_GET_PARSE_STATUS_INFO: {\r
 282 \r
 283                 if (!input\r
 284                         || (((drm_trusted_pd_parse_status_info_s*) (input))->file_path[0] == '\0')\r
 285                         || !output) {\r
 286                         DRM_TRUSTED_CLIENT_EXCEPTION("Invalid argument!!, input = %p, filepath = %s",\r
 287                                         input, (!input) ? "":((drm_trusted_pd_parse_status_info_s*)input)->file_path);\r
 288                         return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 289                 } else {\r
 290 \r
 291                         /* Copy the input to Request Structure */\r
 292                         memcpy(req_data.fixed_data.request_data, input,\r
 293                                         sizeof(drm_trusted_pd_parse_status_info_s));\r
 294 \r
 295                 }\r
 296 \r
 297         }\r
 298                 break;\r
 299 \r
 300         case DRM_TRUSTED_REQ_TYPE_PIFF_GET_LICENSE: {\r
 301 \r
 302                 if (!input\r
 303                         || (((drm_trusted_piff_get_license_info_s*) (input))->lic_header.header\r
 304                                                 == NULL)\r
 305                         || (((drm_trusted_piff_get_license_info_s*) (input))->lic_header.header[0]\r
 306                                                 == '\0'\r
 307                         || (((drm_trusted_piff_get_license_info_s*) (input))->lic_header.header_len\r
 308                                                                 == 0))) {\r
 309                         DRM_TRUSTED_CLIENT_EXCEPTION("Invalid argument!!, input = %p",\r
 310                                         input);\r
 311                         return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 312                 } else {\r
 313 \r
 314                         /* Number of additional data items to be sent */\r
 315                         req_data.fixed_data.num_data_items = 1;\r
 316 \r
 317                         /* Fill details pertaining to additional pointers to be sent */\r
 318                         req_data.fixed_data.data_length[0] = ((drm_trusted_piff_get_license_info_s*) (input))->lic_header.header_len;\r
 319 \r
 320                         /* Allocate memory for data items */\r
 321                         req_data.data_items[0] = (char*) malloc(\r
 322                                         ((drm_trusted_piff_get_license_info_s*) (input))->lic_header.header_len);\r
 323                         if (!req_data.data_items[0]) {\r
 324                                 DRM_TRUSTED_CLIENT_EXCEPTION("Memory Allocation Error!, Buf = %p",\r
 325                                                 req_data.data_items[0]);\r
 326                                 result = DRM_TRUSTED_RETURN_INSUFFICIENT_MEMORY;\r
 327                                 goto ErrorExit;\r
 328                         }\r
 329 \r
 330                         /* Copy into data items */\r
 331                         memcpy( req_data.data_items[0],\r
 332                                         ((drm_trusted_piff_get_license_info_s*) (input))->lic_header.header,\r
 333                                         ((drm_trusted_piff_get_license_info_s*) (input))->lic_header.header_len);\r
 334 \r
 335                         /* Copy the fixed value structure into request data */\r
 336                         memcpy(req_data.fixed_data.request_data, input,\r
 337                                         sizeof(drm_trusted_piff_get_license_info_s));\r
 338 \r
 339                 }\r
 340 \r
 341         }\r
 342                 break;\r
 343 \r
 344         case DRM_TRUSTED_REQ_TYPE_SAPPS_DECRYPT_PACKAGE: {\r
 345 \r
 346                 if (!input\r
 347                         || (((drm_trusted_sapps_decrypt_package_info_s*) (input))->sadcf_filepath[0] == '\0')\r
 348                         || (((drm_trusted_sapps_decrypt_package_info_s*) (input))->decrypt_filepath[0] == '\0')) {\r
 349                         DRM_TRUSTED_CLIENT_EXCEPTION("Invalid argument!!, input = %p", input);\r
 350                         return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 351                 } else {\r
 352 \r
 353                         /* Copy the input to Request Structure */\r
 354                         memcpy(req_data.fixed_data.request_data, input,\r
 355                                         sizeof(drm_trusted_sapps_decrypt_package_info_s));\r
 356                 }\r
 357 \r
 358         }\r
 359                 break;\r
 360 \r
 361         case DRM_TRUSTED_REQ_TYPE_SAPPS_CONSUME_LICENSE: {\r
 362 \r
 363                 if (!input || ((char*) input)[0] == '\0') {\r
 364                         DRM_TRUSTED_CLIENT_EXCEPTION("Invalid argument!!, input = %p",\r
 365                                         input);\r
 366                         return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 367                 } else {\r
 368 \r
 369                         /* Copy the input to Request Structure */\r
 370                         memcpy(req_data.fixed_data.request_data, input,\r
 371                                         sizeof(drm_trusted_sapps_consume_license_info_s));\r
 372                 }\r
 373         }\r
 374                 break;\r
 375 \r
 376         case DRM_TRUSTED_REQ_TYPE_SAPPS_GENERATE_PURCHASE_REQUEST: {\r
 377 \r
 378                 if (!input\r
 379                                 || (((drm_trusted_sapps_gen_purchase_req_info_s*) input)->file_path[0] == '\0')\r
 380                                 || (((drm_trusted_sapps_gen_purchase_req_info_s*) input)->purchase_req_buff_len == 0)\r
 381                                 || (((drm_trusted_sapps_gen_purchase_req_info_s*) input)->rights_url_len == 0)) {\r
 382                         DRM_TRUSTED_CLIENT_EXCEPTION("Invalid argument!!, input = %p", input);\r
 383                         return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 384                 } else {\r
 385                         /* Copy the input to Request Structure */\r
 386                         memcpy(req_data.fixed_data.request_data, input,\r
 387                                         sizeof(drm_trusted_sapps_gen_purchase_req_info_s));\r
 388                 }\r
 389 \r
 390         }\r
 391         break;\r
 392 \r
 393         case DRM_TRUSTED_REQ_TYPE_SAPPS_GENERATE_LICENSE_REQUEST: {\r
 394 \r
 395                 if (!input\r
 396                                 ||(!((drm_trusted_sapps_gen_license_req_info_s*) input)->purchase_req_buff)\r
 397                                 || (((drm_trusted_sapps_gen_license_req_info_s*) input)->purchase_req_buff[0] == '\0')\r
 398                                 || (((drm_trusted_sapps_gen_license_req_info_s*) input)->purchase_req_buff_len == 0)\r
 399                                 || (((drm_trusted_sapps_gen_license_req_info_s*) input)->rights_url_len == 0)\r
 400                                 || (((drm_trusted_sapps_gen_license_req_info_s*) input)->lic_req_buff_len == 0)) {\r
 401                         DRM_TRUSTED_CLIENT_EXCEPTION("Invalid argument!!, input = %p", input);\r
 402                         return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 403                 } else {\r
 404 \r
 405                         /* Copy the input to Request Structure */\r
 406                         memcpy(req_data.fixed_data.request_data, input,\r
 407                                         sizeof(drm_trusted_sapps_gen_license_req_info_s));\r
 408 \r
 409                         /* Number of additional data items to be sent */\r
 410                         req_data.fixed_data.num_data_items = 1;\r
 411 \r
 412                         /* Fill details pertaining to additional pointers to be sent */\r
 413                         req_data.fixed_data.data_length[0] =\r
 414                                         ((drm_trusted_sapps_gen_license_req_info_s*) input)->purchase_req_buff_len;\r
 415 \r
 416                         /* Allocate memory for data items */\r
 417                         req_data.data_items[0] = (char*) malloc(\r
 418                                         req_data.fixed_data.data_length[0]);\r
 419                         if (!req_data.data_items[0]) {\r
 420                                 DRM_TRUSTED_CLIENT_EXCEPTION("Memory Allocation Error!, Buf = %p",\r
 421                                                 req_data.data_items[0]);\r
 422                                 result = DRM_TRUSTED_RETURN_INSUFFICIENT_MEMORY;\r
 423                                 goto ErrorExit;\r
 424                         }\r
 425 \r
 426                         /* Copy the buffer into data items */\r
 427                         memcpy(req_data.data_items[0],\r
 428                                         ((drm_trusted_sapps_gen_license_req_info_s*) input)->purchase_req_buff,\r
 429                                         ((drm_trusted_sapps_gen_license_req_info_s*) input)->purchase_req_buff_len);\r
 430                 }\r
 431         }\r
 432         break;\r
 433 \r
 434 \r
 435         default:\r
 436                 DRM_TRUSTED_CLIENT_EXCEPTION("Invalid argument!!, request_type = %d",\r
 437                                 request_type);\r
 438                 return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 439 \r
 440         }\r
 441 \r
 442         DRM_TRUSTED_CLIENT_LOG("input=%p output=%p", input, output);\r
 443 \r
 444         /* Fill other parameters to be sent */\r
 445 \r
 446         /* Request type to be sent to the server */\r
 447         req_data.fixed_data.req_type = request_type;\r
 448 \r
 449         /* Tell the server which API to be used */\r
 450         req_data.fixed_data.api_name = DRM_TRUSTED_HANDLE_REQUEST;\r
 451 \r
 452         /* Send Data to DRM server */\r
 453         /* Call the Client Communication API */\r
 454         if ((ret_comm = drm_trusted_client_comm(&req_data, &resp_data)) != 0) {\r
 455                 DRM_TRUSTED_CLIENT_EXCEPTION("drm_trusted_client_comm error!!, ret_comm = %d",\r
 456                                 ret_comm);\r
 457                 result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
 458                 goto ErrorExit;\r
 459         }\r
 460 \r
 461         /* Copy the response obtained from the server into the output parameter */\r
 462         if (resp_data.fixed_data.resp_result != 0) {\r
 463                 DRM_TRUSTED_CLIENT_EXCEPTION("Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
 464                                 resp_data.fixed_data.resp_result);\r
 465 \r
 466                 result = resp_data.fixed_data.resp_result;\r
 467                 goto ErrorExit;\r
 468         } else {\r
 469                 DRM_TRUSTED_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x", resp_data.fixed_data.resp_result);\r
 470 \r
 471                 /* Copy the response structure if necessary */\r
 472                 if (DRM_TRUSTED_REQ_TYPE_PD_GET_PARSE_STATUS_INFO == request_type) {\r
 473 \r
 474                         /* Copy the response into the output data */\r
 475                         memcpy(output, resp_data.fixed_data.response_data,\r
 476                                         sizeof(drm_trusted_pd_parse_status_resp_s));\r
 477                 }\r
 478 \r
 479                 if (DRM_TRUSTED_REQ_TYPE_SAPPS_GENERATE_PURCHASE_REQUEST\r
 480                                 == request_type) {\r
 481 \r
 482                         /* Copy the response onto the output structure */\r
 483                         memcpy(output, resp_data.fixed_data.response_data,\r
 484                                         sizeof(drm_trusted_sapps_gen_purchase_req_resp_s));\r
 485 \r
 486                         /* Copy the data items */\r
 487                         memcpy( ((drm_trusted_sapps_gen_purchase_req_resp_s*) output)->purchase_req_buff,\r
 488                                         resp_data.data_items[0],\r
 489                                         resp_data.fixed_data.data_length[0]);\r
 490                 }\r
 491 \r
 492 \r
 493                 if (DRM_TRUSTED_REQ_TYPE_SAPPS_GENERATE_LICENSE_REQUEST == request_type) {\r
 494 \r
 495                         /* Copy the response onto the output structure */\r
 496                         memcpy(output, resp_data.fixed_data.response_data,\r
 497                                         sizeof(drm_trusted_sapps_gen_license_req_resp_s));\r
 498 \r
 499                         /* Copy the data items */\r
 500                         memcpy( ((drm_trusted_sapps_gen_license_req_resp_s*) output)->lic_req_buff,\r
 501                                         resp_data.data_items[0],\r
 502                                         resp_data.fixed_data.data_length[0]);\r
 503                 }\r
 504 \r
 505         }\r
 506 \r
 507 ErrorExit:\r
 508 \r
 509         /* Free Request Data memory */\r
 510         for (int i = 0; i < req_data.fixed_data.num_data_items; i++) {\r
 511                 if (req_data.data_items[i])\r
 512                         free(req_data.data_items[i]);\r
 513         }\r
 514 \r
 515         /* Free Response Data memory */\r
 516         for (int i = 0; i < resp_data.fixed_data.num_data_items; i++) {\r
 517                 if (resp_data.data_items[i])\r
 518                         free(resp_data.data_items[i]);\r
 519         }\r
 520 \r
 521         if (result != DRM_TRUSTED_RETURN_SUCCESS) {\r
 522                 /* Failure */\r
 523                 DRM_TRUSTED_CLIENT_EXCEPTION("failed:result=0x%x", result);\r
 524                 return result;\r
 525         } else {\r
 526                 /* Success */\r
 527                 DRM_TRUSTED_CLIENT_LOG("Success:result=0x%x", result);\r
 528                 return result;\r
 529         }\r
 530 \r
 531 }\r
 532 \r
 533 /**\r
 534  * An application can Open Decrypt Session for consumption.\r
 535  *\r
 536  * @param[in]   input_data              Pointer to drm_trusted_open_decrypt_info_s\r
 537  * @param[out]  output_data             Pointer to drm_trusted_open_decrypt_resp_data_s\r
 538  * @param[out]  pHandle                 Pointer to DRM_DECRYPT_HANDLE\r
 539  *\r
 540  * @return              0 on success, else a negative error value\r
 541  * @retval              DRM_TRUSTED_RETURN_SUCCESS on success\r
 542  * @retval              DRM_TRUSTED_RETURN_INVALID_ARG if arguments are invalid\r
 543  * @retval              DRM_TRUSTED_RETURN_COMMUNICATION_ERROR if socket error\r
 544  * @retval              DRM_TRUSTED_RETURN_INTERNAL_ERROR if operation error\r
 545  * @retval              DRM_TRUSTED_RETURN_INSUFFICIENT_MEMORY if memory not available\r
 546  * @remarks             In drm_trusted_open_decrypt_info_s structure\r
 547  *                              OMA, PR, OMA PD: filepath = DRM File path & lic_header = {0}\r
 548  *                              PIFF: filepath = {0} & lic_header = Header from manifest file\r
 549  * @see\r
 550  * @since       0.1\r
 551  */\r
 552 EXPORT_API int drm_trusted_open_decrypt_session(drm_trusted_open_decrypt_info_s *input_data,\r
 553                 drm_trusted_open_decrypt_resp_data_s *output_data, DRM_DECRYPT_HANDLE *pHandle)\r
 554 {\r
 555 \r
 556         /* Local Variables */\r
 557         drm_trusted_result_e result = DRM_TRUSTED_RETURN_SUCCESS;\r
 558         drm_trusted_request_data_s req_data;\r
 559         drm_trusted_response_data_s resp_data;\r
 560         int ret_comm = 0;\r
 561 \r
 562         /* memset the structures */\r
 563         memset(&req_data, 0x0, sizeof(drm_trusted_request_data_s));\r
 564         memset(&resp_data, 0x0, sizeof(drm_trusted_response_data_s));\r
 565 \r
 566         /* Check Input & Output Parameters */\r
 567         if (!input_data\r
 568                         || (input_data->filePath[0] == '\0'\r
 569                                         && (!(input_data->lic_header.header)\r
 570                                                         || input_data->lic_header.header[0] == '\0'))\r
 571                         || !output_data || !pHandle) {\r
 572                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
 573                                 "Invalid Args, input_data = %p, output_data = %p, pHandle = %p",\r
 574                                 input_data, output_data, pHandle);\r
 575                 return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 576         }\r
 577 \r
 578         DRM_TRUSTED_CLIENT_LOG("input_data = %p, output_data = %p, pHandle = %p",\r
 579                         input_data, output_data, pHandle);\r
 580 \r
 581         /* Copy the input to Request Structure */\r
 582         memcpy(req_data.fixed_data.request_data, input_data,\r
 583                         sizeof(drm_trusted_open_decrypt_info_s));\r
 584 \r
 585         /* Copy the handle into the request structure */\r
 586         req_data.fixed_data.pHandle = *pHandle;\r
 587 \r
 588         /* Tell the server which API to be used */\r
 589         req_data.fixed_data.api_name = DRM_TRUSTED_OPEN_DECRYPT_SESSION;\r
 590 \r
 591 \r
 592         if (input_data->lic_header.header != NULL\r
 593                         && input_data->lic_header.header[0] != '\0'\r
 594                         && input_data->lic_header.header_len > 0) {\r
 595 \r
 596                 /* Number of additional data items to be sent */\r
 597                 req_data.fixed_data.num_data_items = 1;\r
 598 \r
 599                 /* Fill details pertaining to additional pointers to be sent */\r
 600                 req_data.fixed_data.data_length[0] = input_data->lic_header.header_len;\r
 601 \r
 602                 /* Allocate memory for data items */\r
 603                 req_data.data_items[0] = (char*) malloc(\r
 604                                 input_data->lic_header.header_len);\r
 605                 if (!req_data.data_items[0]) {\r
 606                         DRM_TRUSTED_CLIENT_EXCEPTION("Memory Allocation Error!, Buf = %p",\r
 607                                         req_data.data_items[0]);\r
 608                         result = DRM_TRUSTED_RETURN_INSUFFICIENT_MEMORY;\r
 609                         goto ErrorExit;\r
 610                 }\r
 611 \r
 612                 /* Copy into data items */\r
 613                 memcpy(req_data.data_items[0], input_data->lic_header.header,\r
 614                                 input_data->lic_header.header_len);\r
 615         }\r
 616 \r
 617         /* Send Data to DRM server */\r
 618         /* Call the Client Communication API */\r
 619         if ((ret_comm = drm_trusted_client_comm(&req_data, &resp_data)) != 0) {\r
 620                 DRM_TRUSTED_CLIENT_EXCEPTION("drm_trusted_client_comm error!!, ret_comm = %d",\r
 621                                 ret_comm);\r
 622                 result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
 623                 goto ErrorExit;\r
 624         }\r
 625 \r
 626         /* Copy the response obtained from the server into the output parameter */\r
 627         if (resp_data.fixed_data.resp_result != 0) {\r
 628                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
 629                                 "Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
 630                                 resp_data.fixed_data.resp_result);\r
 631                 result = resp_data.fixed_data.resp_result;\r
 632                 goto ErrorExit;\r
 633         } else {\r
 634                 DRM_TRUSTED_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x",\r
 635                                 resp_data.fixed_data.resp_result);\r
 636 \r
 637                 /* Store the handle from the server into input handle */\r
 638                 *pHandle = resp_data.fixed_data.pHandle;\r
 639 \r
 640                 /* Copy the response into the output data */\r
 641                 memcpy(output_data, resp_data.fixed_data.response_data,\r
 642                                 sizeof(drm_trusted_open_decrypt_resp_data_s));\r
 643         }\r
 644 \r
 645 ErrorExit:\r
 646 \r
 647         /* Free Request Data memory */\r
 648         for (int i = 0; i < req_data.fixed_data.num_data_items; i++) {\r
 649                 if (req_data.data_items[i])\r
 650                         free(req_data.data_items[i]);\r
 651         }\r
 652 \r
 653         if (result != DRM_TRUSTED_RETURN_SUCCESS) {\r
 654                 /* Failure */\r
 655                 DRM_TRUSTED_CLIENT_EXCEPTION("failed:result=0x%x", result);\r
 656                 return result;\r
 657         } else {\r
 658                 /* Success */\r
 659                 DRM_TRUSTED_CLIENT_LOG("Success:result=0x%x", result);\r
 660                 return result;\r
 661         }\r
 662 \r
 663 \r
 664 }\r
 665 \r
 666 /**\r
 667  * An application can Read Decrypt Session for consumption.\r
 668  *\r
 669  * @param[in]   pHandle                 DRM_DECRYPT_HANDLE obtained from Open Decrypt Session\r
 670  * @param[in]   input_data              Pointer to drm_trusted_payload_info_s\r
 671  * @param[out]  output_data             Pointer to drm_trusted_read_decrypt_resp_data_s\r
 672  *\r
 673  * @return              0 on success, else a negative error value\r
 674  * @retval              DRM_TRUSTED_RETURN_SUCCESS on success\r
 675  * @retval              DRM_TRUSTED_RETURN_INVALID_ARG if arguments are invalid\r
 676  * @retval              DRM_TRUSTED_RETURN_COMMUNICATION_ERROR if socket error\r
 677  * @retval              DRM_TRUSTED_RETURN_INTERNAL_ERROR if operation error\r
 678  * @retval              DRM_TRUSTED_RETURN_INSUFFICIENT_MEMORY if memory not available\r
 679  * @remarks             In drm_trusted_payload_info_s structure\r
 680  *                              OMA,OMA_PD:  input = payload_data (Encrypted buffer)\r
 681  *                                                       output = payload_data (Decrypted buffer)\r
 682  *\r
 683  *                              PR,PIFF:         input = payload_data (Encrypted buffer)\r
 684  *                                                       input = payload_iv (Initialisation Vector)\r
 685  *                                                       output = payload_data (Decrypted buffer)\r
 686  * @see\r
 687  * @since       0.1\r
 688  */\r
 689 EXPORT_API int drm_trusted_read_decrypt_session(DRM_DECRYPT_HANDLE pHandle,\r
 690                 drm_trusted_payload_info_s *input_data, drm_trusted_read_decrypt_resp_data_s *output_data)\r
 691 {\r
 692 \r
 693         /* Local Variables */\r
 694         drm_trusted_result_e result = DRM_TRUSTED_RETURN_SUCCESS;\r
 695         drm_trusted_request_data_s req_data;\r
 696         drm_trusted_response_data_s resp_data;\r
 697         int ret_comm = 0;\r
 698 \r
 699         /* memset the structures */\r
 700         memset(&req_data, 0x0, sizeof(drm_trusted_request_data_s));\r
 701         memset(&resp_data, 0x0, sizeof(drm_trusted_response_data_s));\r
 702 \r
 703         /* Check Input & Output Parameters */\r
 704         if (!input_data || !output_data || !pHandle) {\r
 705                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
 706                                 "Invalid Args, input_data = %p, output_data = %p, pHandle = %p",\r
 707                                 input_data, output_data, pHandle);\r
 708                 return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 709         }\r
 710 \r
 711         DRM_TRUSTED_CLIENT_LOG("input_data = %p, output_data = %p, pHandle = %p",\r
 712                         input_data, output_data, pHandle);\r
 713 \r
 714         /* Copy the input to Request Structure */\r
 715         memcpy(req_data.fixed_data.request_data, input_data,\r
 716                         sizeof(drm_trusted_payload_info_s));\r
 717 \r
 718         /* Copy the handle into the request structure */\r
 719         req_data.fixed_data.pHandle = pHandle;\r
 720 \r
 721         /* Tell the server which API to be used */\r
 722         req_data.fixed_data.api_name = DRM_TRUSTED_READ_DECRYPT_SESSION;\r
 723 \r
 724         /* Number of additional data items to be sent */\r
 725 \r
 726         /* Send items that is filled by application */\r
 727         if (!(input_data->payload_data) || input_data->payload_data_len == 0) {\r
 728                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
 729                                 "Invalid Args, payload_data = %p, payload_data_len = %d",\r
 730                                 input_data->payload_data, input_data->payload_data_len);\r
 731                 return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 732         } else {\r
 733                 req_data.fixed_data.num_data_items++;\r
 734         }\r
 735 \r
 736         if ((input_data->payload_iv && input_data->payload_iv_len == 0)\r
 737                         || (input_data->payload_iv_len != 0 && !(input_data->payload_iv))) {\r
 738                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
 739                                 "Invalid Args, payload_iv = %p, payload_iv_len = %d",\r
 740                                 input_data->payload_iv, input_data->payload_iv_len);\r
 741                 return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 742         } else {\r
 743                 req_data.fixed_data.num_data_items++;\r
 744         }\r
 745 \r
 746         /* Fill details pertaining to additional pointers to be sent */\r
 747 \r
 748         /* Copy Payload data */\r
 749         req_data.fixed_data.data_length[0] = input_data->payload_data_len;\r
 750         req_data.data_items[0] = (char*)malloc(req_data.fixed_data.data_length[0]);\r
 751         if (!req_data.data_items[0]) {\r
 752                 DRM_TRUSTED_CLIENT_EXCEPTION("Memory Allocation Error!, Buf = %p",\r
 753                                 req_data.data_items[0]);\r
 754                 goto ErrorExit;\r
 755         }\r
 756 \r
 757         memcpy(req_data.data_items[0], input_data->payload_data,\r
 758                         input_data->payload_data_len);\r
 759 \r
 760         /* Copy Payload IV */\r
 761         req_data.fixed_data.data_length[1] = input_data->payload_iv_len;\r
 762         req_data.data_items[1] = (char*)malloc(req_data.fixed_data.data_length[1]);\r
 763         if (!req_data.data_items[1]) {\r
 764                 DRM_TRUSTED_CLIENT_EXCEPTION("Memory Allocation Error!, Buf = %p",\r
 765                                 req_data.data_items[1]);\r
 766                 goto ErrorExit;\r
 767         }\r
 768 \r
 769         memcpy(req_data.data_items[1], input_data->payload_iv,\r
 770                                 input_data->payload_iv_len);\r
 771 \r
 772         /* Send Data to DRM server */\r
 773         /* Call the Client Communication API */\r
 774         if ((ret_comm = drm_trusted_client_comm(&req_data, &resp_data)) != 0) {\r
 775                 DRM_TRUSTED_CLIENT_EXCEPTION("drm_trusted_client_comm error!!, ret_comm = %d",\r
 776                                 ret_comm);\r
 777                 result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
 778                 goto ErrorExit;\r
 779         }\r
 780 \r
 781         /* Copy the response obtained from the server into the output parameter */\r
 782         if (resp_data.fixed_data.resp_result != 0) {\r
 783                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
 784                                 "Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
 785                                 resp_data.fixed_data.resp_result);\r
 786                 result = resp_data.fixed_data.resp_result;\r
 787                 goto ErrorExit;\r
 788         } else {\r
 789                 DRM_TRUSTED_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x",\r
 790                                 resp_data.fixed_data.resp_result);\r
 791 \r
 792                 /* Copy the decrypted payload buffer */\r
 793                 input_data->payload_data_len = resp_data.fixed_data.data_length[0];\r
 794                 memcpy(input_data->payload_data, resp_data.data_items[0],\r
 795                                 resp_data.fixed_data.data_length[0]);\r
 796 \r
 797                 /* Copy the response from the server into output data */\r
 798                 memcpy(output_data, resp_data.fixed_data.response_data,\r
 799                                 sizeof(drm_trusted_read_decrypt_resp_data_s));\r
 800         }\r
 801 \r
 802 ErrorExit:\r
 803 \r
 804         /* Free Request data memory */\r
 805         for (int i = 0; i < req_data.fixed_data.num_data_items; i++) {\r
 806                 if (req_data.data_items[i])\r
 807                         free(req_data.data_items[i]);\r
 808         }\r
 809 \r
 810         /* Free Response data memory */\r
 811         if (resp_data.data_items[0])\r
 812                 free (resp_data.data_items[0]);\r
 813 \r
 814         if (result != DRM_TRUSTED_RETURN_SUCCESS) {\r
 815                 /* Failure */\r
 816                 DRM_TRUSTED_CLIENT_EXCEPTION("failed:result=0x%x", result);\r
 817                 return result;\r
 818         } else {\r
 819                 /* Success */\r
 820                 DRM_TRUSTED_CLIENT_LOG("Success:result=0x%x", result);\r
 821                 return result;\r
 822         }\r
 823 \r
 824 }\r
 825 \r
 826 /**\r
 827  * An application can Seek Decrypt Session for consumption.\r
 828  *\r
 829  * @param[in]   pHandle                 DRM_DECRYPT_HANDLE obtained from Open Decrypt Session\r
 830  * @param[in]   input_data              Pointer to drm_trusted_seek_decrypt_info_s\r
 831  *\r
 832  * @return              0 on success, else a negative error value\r
 833  * @retval              DRM_TRUSTED_RETURN_SUCCESS on success\r
 834  * @retval              DRM_TRUSTED_RETURN_INVALID_ARG if arguments are invalid\r
 835  * @retval              DRM_TRUSTED_RETURN_COMMUNICATION_ERROR if socket error\r
 836  * @retval              DRM_TRUSTED_RETURN_INTERNAL_ERROR if operation error\r
 837  * @remarks\r
 838  * @see\r
 839  * @since       0.1\r
 840  */\r
 841 EXPORT_API int drm_trusted_seek_decrypt_session(DRM_DECRYPT_HANDLE pHandle,\r
 842                 drm_trusted_seek_decrypt_info_s *input_data)\r
 843 {\r
 844         /* Local Variables */\r
 845         drm_trusted_result_e result = DRM_TRUSTED_RETURN_SUCCESS;\r
 846         drm_trusted_request_data_s req_data;\r
 847         drm_trusted_response_data_s resp_data;\r
 848         int ret_comm = 0;\r
 849 \r
 850         /* memset the structures */\r
 851         memset(&req_data, 0x0, sizeof(drm_trusted_request_data_s));\r
 852         memset(&resp_data, 0x0, sizeof(drm_trusted_response_data_s));\r
 853 \r
 854         /* Check Input & Output Parameters */\r
 855         if (!input_data || !pHandle) {\r
 856                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
 857                                 "Invalid Args, input_data = %p, pHandle = %p",\r
 858                                 input_data, pHandle);\r
 859                 return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 860         }\r
 861 \r
 862         DRM_TRUSTED_CLIENT_LOG("input_data = %p, pHandle = %p",\r
 863                         input_data, pHandle);\r
 864 \r
 865         /* Copy the input to Request Structure */\r
 866         memcpy(req_data.fixed_data.request_data, input_data,\r
 867                         sizeof(drm_trusted_seek_decrypt_info_s));\r
 868 \r
 869         /* Copy the handle into the request structure */\r
 870         req_data.fixed_data.pHandle = pHandle;\r
 871 \r
 872         /* Tell the server which API to be used */\r
 873         req_data.fixed_data.api_name = DRM_TRUSTED_SEEK_DECRYPT_SESSION;\r
 874 \r
 875         /* Send Data to DRM server */\r
 876         /* Call the Client Communication API */\r
 877         if ((ret_comm = drm_trusted_client_comm(&req_data, &resp_data)) != 0) {\r
 878                 DRM_TRUSTED_CLIENT_EXCEPTION("drm_trusted_client_comm error!!, ret_comm = %d",\r
 879                                 ret_comm);\r
 880                 result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
 881                 goto ErrorExit;\r
 882         }\r
 883 \r
 884         /* Copy the response obtained from the server into the output parameter */\r
 885         if (resp_data.fixed_data.resp_result != 0) {\r
 886                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
 887                                 "Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
 888                                 resp_data.fixed_data.resp_result);\r
 889                 result = resp_data.fixed_data.resp_result;\r
 890                 goto ErrorExit;\r
 891         } else {\r
 892                 DRM_TRUSTED_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x",\r
 893                                 resp_data.fixed_data.resp_result);\r
 894         }\r
 895 \r
 896 ErrorExit:\r
 897 \r
 898         if (result != DRM_TRUSTED_RETURN_SUCCESS) {\r
 899                 /* Failure */\r
 900                 DRM_TRUSTED_CLIENT_EXCEPTION("failed:result=0x%x", result);\r
 901                 return result;\r
 902         } else {\r
 903                 /* Success */\r
 904                 DRM_TRUSTED_CLIENT_LOG("Success:result=0x%x", result);\r
 905                 return result;\r
 906         }\r
 907 \r
 908 }\r
 909 \r
 910 /**\r
 911  * An application can Tell Decrypt Session for consumption.\r
 912  *\r
 913  * @param[in]   pHandle                 DRM_DECRYPT_HANDLE obtained from Open Decrypt Session\r
 914  * @param[out]  output_data             Pointer to drm_trusted_tell_decrypt_resp_data_s\r
 915  *\r
 916  * @return              0 on success, else a negative error value\r
 917  * @retval              DRM_TRUSTED_RETURN_SUCCESS on success\r
 918  * @retval              DRM_TRUSTED_RETURN_INVALID_ARG if arguments are invalid\r
 919  * @retval              DRM_TRUSTED_RETURN_COMMUNICATION_ERROR if socket error\r
 920  * @retval              DRM_TRUSTED_RETURN_INTERNAL_ERROR if operation error\r
 921  * @remarks\r
 922  * @see\r
 923  * @since       0.1\r
 924  */\r
 925 EXPORT_API int drm_trusted_tell_decrypt_session(DRM_DECRYPT_HANDLE pHandle,\r
 926                 drm_trusted_tell_decrypt_resp_data_s *output_data)\r
 927 {\r
 928         /* Local Variables */\r
 929         drm_trusted_result_e result = DRM_TRUSTED_RETURN_SUCCESS;\r
 930         drm_trusted_request_data_s req_data;\r
 931         drm_trusted_response_data_s resp_data;\r
 932         int ret_comm = 0;\r
 933 \r
 934         /* memset the structures */\r
 935         memset(&req_data, 0x0, sizeof(drm_trusted_request_data_s));\r
 936         memset(&resp_data, 0x0, sizeof(drm_trusted_response_data_s));\r
 937 \r
 938         /* Check Input & Output Parameters */\r
 939         if (!output_data || !pHandle) {\r
 940                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
 941                                 "Invalid Args, output_data = %p, pHandle = %p",\r
 942                                 output_data, pHandle);\r
 943                 return DRM_TRUSTED_RETURN_INVALID_ARG;\r
 944         }\r
 945 \r
 946         DRM_TRUSTED_CLIENT_LOG("output_data = %p, pHandle = %p",\r
 947                         output_data, pHandle);\r
 948 \r
 949         /* Copy the handle into the request structure */\r
 950         req_data.fixed_data.pHandle = pHandle;\r
 951 \r
 952         /* Tell the server which API to be used */\r
 953         req_data.fixed_data.api_name = DRM_TRUSTED_TELL_DECRYPT_SESSION;\r
 954 \r
 955         /* Send Data to DRM server */\r
 956         /* Call the Client Communication API */\r
 957         if ((ret_comm = drm_trusted_client_comm(&req_data, &resp_data)) != 0) {\r
 958                 DRM_TRUSTED_CLIENT_EXCEPTION("drm_trusted_client_comm error!!, ret_comm = %d",\r
 959                                 ret_comm);\r
 960                 result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
 961                 goto ErrorExit;\r
 962         }\r
 963 \r
 964         /* Copy the response obtained from the server into the output parameter */\r
 965         if (resp_data.fixed_data.resp_result != 0) {\r
 966                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
 967                                 "Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
 968                                 resp_data.fixed_data.resp_result);\r
 969                 result = resp_data.fixed_data.resp_result;\r
 970                 goto ErrorExit;\r
 971         } else {\r
 972                 DRM_TRUSTED_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x",\r
 973                                 resp_data.fixed_data.resp_result);\r
 974 \r
 975                 /* Copy the response obtained from the server into the output data */\r
 976                 memcpy(output_data, resp_data.fixed_data.response_data,\r
 977                                 sizeof(drm_trusted_tell_decrypt_resp_data_s));\r
 978         }\r
 979 \r
 980 ErrorExit:\r
 981 \r
 982         if (result != DRM_TRUSTED_RETURN_SUCCESS) {\r
 983                 /* Failure */\r
 984                 DRM_TRUSTED_CLIENT_EXCEPTION("failed:result=0x%x", result);\r
 985                 return result;\r
 986         } else {\r
 987                 /* Success */\r
 988                 DRM_TRUSTED_CLIENT_LOG("Success:result=0x%x", result);\r
 989                 return result;\r
 990         }\r
 991 \r
 992 }\r
 993 \r
 994 /**\r
 995  * An application can Set Decrypt state during consumption.\r
 996  *\r
 997  * @param[in]   pHandle                 DRM_DECRYPT_HANDLE obtained from Open Decrypt Session\r
 998  * @param[in]   input_data              Pointer to drm_trusted_set_consumption_state_info_s\r
 999  *\r
1000  * @return              0 on success, else a negative error value\r
1001  * @retval              DRM_TRUSTED_RETURN_SUCCESS on success\r
1002  * @retval              DRM_TRUSTED_RETURN_INVALID_ARG if arguments are invalid\r
1003  * @retval              DRM_TRUSTED_RETURN_COMMUNICATION_ERROR if socket error\r
1004  * @retval              DRM_TRUSTED_RETURN_INTERNAL_ERROR if operation error\r
1005  * @remarks\r
1006  * @see\r
1007  * @since       0.1\r
1008  */\r
1009 EXPORT_API int drm_trusted_set_decrypt_state(DRM_DECRYPT_HANDLE pHandle,\r
1010                 drm_trusted_set_consumption_state_info_s *input_data)\r
1011 {\r
1012 \r
1013         /* Local Variables */\r
1014         drm_trusted_result_e result = DRM_TRUSTED_RETURN_SUCCESS;\r
1015         drm_trusted_request_data_s req_data;\r
1016         drm_trusted_response_data_s resp_data;\r
1017         int ret_comm = 0;\r
1018 \r
1019         /* memset the structures */\r
1020         memset(&req_data, 0x0, sizeof(drm_trusted_request_data_s));\r
1021         memset(&resp_data, 0x0, sizeof(drm_trusted_response_data_s));\r
1022 \r
1023         /* Check Input & Output Parameters */\r
1024         if (!input_data || !pHandle) {\r
1025                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
1026                                 "Invalid Args, input_data = %p, pHandle = %p",\r
1027                                 input_data, pHandle);\r
1028                 return DRM_TRUSTED_RETURN_INVALID_ARG;\r
1029         }\r
1030 \r
1031         DRM_TRUSTED_CLIENT_LOG("input_data = %p, pHandle = %p",\r
1032                         input_data, pHandle);\r
1033 \r
1034         /* Copy the input to Request Structure */\r
1035         memcpy(req_data.fixed_data.request_data, input_data,\r
1036                         sizeof(drm_trusted_set_consumption_state_info_s));\r
1037 \r
1038         /* Copy the handle into the request structure */\r
1039         req_data.fixed_data.pHandle = pHandle;\r
1040 \r
1041         /* Tell the server which API to be used */\r
1042         req_data.fixed_data.api_name = DRM_TRUSTED_SET_DECRYPT_STATE;\r
1043 \r
1044         /* Send Data to DRM server */\r
1045         /* Call the Client Communication API */\r
1046         if ((ret_comm = drm_trusted_client_comm(&req_data, &resp_data)) != 0) {\r
1047                 DRM_TRUSTED_CLIENT_EXCEPTION("drm_trusted_client_comm error!!, ret_comm = %d",\r
1048                                 ret_comm);\r
1049                 result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
1050                 goto ErrorExit;\r
1051         }\r
1052 \r
1053         /* Copy the response obtained from the server into the output parameter */\r
1054         if (resp_data.fixed_data.resp_result != 0) {\r
1055                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
1056                                 "Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
1057                                 resp_data.fixed_data.resp_result);\r
1058                 result = resp_data.fixed_data.resp_result;\r
1059                 goto ErrorExit;\r
1060         } else {\r
1061                 DRM_TRUSTED_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x",\r
1062                                 resp_data.fixed_data.resp_result);\r
1063         }\r
1064 \r
1065 ErrorExit:\r
1066 \r
1067         if (result != DRM_TRUSTED_RETURN_SUCCESS) {\r
1068                 /* Failure */\r
1069                 DRM_TRUSTED_CLIENT_EXCEPTION("failed:result=0x%x", result);\r
1070                 return result;\r
1071         } else {\r
1072                 /* Success */\r
1073                 DRM_TRUSTED_CLIENT_LOG("Success:result=0x%x", result);\r
1074                 return result;\r
1075         }\r
1076 \r
1077 }\r
1078 \r
1079 /**\r
1080  * An application can Close decrypt session for consumption.\r
1081  *\r
1082  * @param[in]   pHandle         Pointer to DRM_DECRYPT_HANDLE obtained from Open Decrypt Session\r
1083  *\r
1084  * @return              0 on success, else a negative error value\r
1085  * @retval              DRM_TRUSTED_RETURN_SUCCESS on success\r
1086  * @retval              DRM_TRUSTED_RETURN_INVALID_ARG if arguments are invalid\r
1087  * @retval              DRM_TRUSTED_RETURN_COMMUNICATION_ERROR if socket error\r
1088  * @retval              DRM_TRUSTED_RETURN_INTERNAL_ERROR if operation error\r
1089  * @remarks\r
1090  * @see\r
1091  * @since       0.1\r
1092  */\r
1093 EXPORT_API int drm_trusted_close_decrypt_session(DRM_DECRYPT_HANDLE *pHandle)\r
1094 {\r
1095         /* Local Variables */\r
1096         drm_trusted_result_e result = DRM_TRUSTED_RETURN_SUCCESS;\r
1097         drm_trusted_request_data_s req_data;\r
1098         drm_trusted_response_data_s resp_data;\r
1099         int ret_comm = 0;\r
1100 \r
1101         /* memset the structures */\r
1102         memset(&req_data, 0x0, sizeof(drm_trusted_request_data_s));\r
1103         memset(&resp_data, 0x0, sizeof(drm_trusted_response_data_s));\r
1104 \r
1105         /* Check Input & Output Parameters */\r
1106         if (!pHandle || !(*pHandle)) {\r
1107                 DRM_TRUSTED_CLIENT_EXCEPTION("Invalid Args, pHandle = %p, *pHandle = %p",\r
1108                                 pHandle, (!pHandle) ? NULL : *pHandle);\r
1109                 return DRM_TRUSTED_RETURN_INVALID_ARG;\r
1110         }\r
1111 \r
1112         DRM_TRUSTED_CLIENT_LOG("pHandle = %p, *pHandle = %p",\r
1113                         pHandle, *pHandle);\r
1114 \r
1115         /* Copy the handle into the request structure */\r
1116         req_data.fixed_data.pHandle = *pHandle;\r
1117 \r
1118         /* Tell the server which API to be used */\r
1119         req_data.fixed_data.api_name = DRM_TRUSTED_CLOSE_DECRYPT_SESSION;\r
1120 \r
1121         /* Send Data to DRM server */\r
1122         /* Call the Client Communication API */\r
1123         if ((ret_comm = drm_trusted_client_comm(&req_data, &resp_data)) != 0) {\r
1124                 DRM_TRUSTED_CLIENT_EXCEPTION("drm_trusted_client_comm error!!, ret_comm = %d",\r
1125                                 ret_comm);\r
1126                 result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
1127                 goto ErrorExit;\r
1128         }\r
1129 \r
1130         /* Copy the response obtained from the server into the output parameter */\r
1131         if (resp_data.fixed_data.resp_result != 0) {\r
1132                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
1133                                 "Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
1134                                 resp_data.fixed_data.resp_result);\r
1135                 result = resp_data.fixed_data.resp_result;\r
1136                 goto ErrorExit;\r
1137         } else {\r
1138                 DRM_TRUSTED_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x",\r
1139                                 resp_data.fixed_data.resp_result);\r
1140         }\r
1141 \r
1142 ErrorExit:\r
1143 \r
1144         if (result != DRM_TRUSTED_RETURN_SUCCESS) {\r
1145                 /* Failure */\r
1146                 DRM_TRUSTED_CLIENT_EXCEPTION("failed:result=0x%x", result);\r
1147                 return result;\r
1148         } else {\r
1149                 /* Success */\r
1150                 DRM_TRUSTED_CLIENT_LOG("Success:result=0x%x", result);\r
1151                 return result;\r
1152         }\r
1153 \r
1154 }\r
1155 \r
1156 /**\r
1157  * An application can prepare to convert a DRM file in OMADRM-v1.\r
1158  * If a type of DRM file is FL, CD or FL-SD type, application can convert to SD type.\r
1159  * This function prepare for converting and create file.\r
1160  *\r
1161  * @param[in]   input           Pointer to drm_trusted_opn_conv_info_s\r
1162  * @param[out]  hConvert        Pointer to Open Convert Handle(DRM_TRUSTED_CONVERT_HANDLE)\r
1163  *\r
1164  * @return              0 on success, else a negative error value\r
1165  * @retval              DRM_TRUSTED_RETURN_SUCCESS on success\r
1166  * @retval              DRM_TRUSTED_RETURN_INVALID_ARG if arguments are invalid\r
1167  * @retval              DRM_TRUSTED_RETURN_COMMUNICATION_ERROR if socket error\r
1168  * @retval              DRM_TRUSTED_RETURN_INTERNAL_ERROR if operation error\r
1169  * @remarks\r
1170  * @see\r
1171  * @since       0.1\r
1172  */\r
1173 EXPORT_API int drm_trusted_open_convert(drm_trusted_opn_conv_info_s *input,\r
1174                 DRM_TRUSTED_CONVERT_HANDLE *hConvert)\r
1175 {\r
1176         /* Local Variables */\r
1177         drm_trusted_result_e result = DRM_TRUSTED_RETURN_SUCCESS;\r
1178         drm_trusted_request_data_s req_data;\r
1179         drm_trusted_response_data_s resp_data;\r
1180         int ret_comm = 0;\r
1181 \r
1182         /* memset the structures */\r
1183         memset(&req_data, 0x0, sizeof(drm_trusted_request_data_s));\r
1184         memset(&resp_data, 0x0, sizeof(drm_trusted_response_data_s));\r
1185 \r
1186         /* Check Input & Output Parameters */\r
1187         if (!input || !hConvert) {\r
1188                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
1189                                 "Invalid Args, input = %p, hConvert = %p, *hConvert = %p",\r
1190                                 input, hConvert, (!hConvert) ? NULL : *hConvert);\r
1191                 return DRM_TRUSTED_RETURN_INVALID_ARG;\r
1192         }\r
1193 \r
1194         /* Copy the input to Request Structure */\r
1195         memcpy(req_data.fixed_data.request_data, input,\r
1196                         sizeof(drm_trusted_opn_conv_info_s));\r
1197 \r
1198         /* Copy the handle into the request structure */\r
1199         req_data.fixed_data.hConvert = *hConvert;\r
1200 \r
1201         /* Tell the server which API to be used */\r
1202         req_data.fixed_data.api_name = DRM_TRUSTED_OPEN_CONVERT;\r
1203 \r
1204         /* Send Data to DRM server */\r
1205         /* Call the Client Communication API */\r
1206         if ((ret_comm = drm_trusted_client_comm(&req_data, &resp_data)) != 0) {\r
1207                 DRM_TRUSTED_CLIENT_EXCEPTION("drm_trusted_client_comm error!!, ret_comm = %d",\r
1208                                 ret_comm);\r
1209                 result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
1210                 goto ErrorExit;\r
1211         }\r
1212 \r
1213         /* Copy the response obtained from the server into the output parameter */\r
1214         if (resp_data.fixed_data.resp_result != 0) {\r
1215                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
1216                                 "Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
1217                                 resp_data.fixed_data.resp_result);\r
1218                 result = resp_data.fixed_data.resp_result;\r
1219                 goto ErrorExit;\r
1220         } else {\r
1221                 DRM_TRUSTED_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x",\r
1222                                 resp_data.fixed_data.resp_result);\r
1223 \r
1224                 /* Store the Convert handle from the server into input handle */\r
1225                 *hConvert = resp_data.fixed_data.hConvert;\r
1226         }\r
1227 \r
1228 ErrorExit:\r
1229 \r
1230         if (result != DRM_TRUSTED_RETURN_SUCCESS) {\r
1231                 /* Failure */\r
1232                 DRM_TRUSTED_CLIENT_EXCEPTION("failed:result=0x%x", result);\r
1233                 return result;\r
1234         } else {\r
1235                 /* Success */\r
1236                 DRM_TRUSTED_CLIENT_LOG("Success:result=0x%x", result);\r
1237                 return result;\r
1238         }\r
1239 }\r
1240 \r
1241 /**\r
1242  * An application can write converted data.\r
1243  *\r
1244  * @param[in]   input           Pointer to drm_trusted_opn_conv_info_s\r
1245  * @param[out]  output          Pointer to drm_trusted_write_conv_resp_s\r
1246  * @param[in]   hConvert        Pointer to Open Convert Handle(DRM_TRUSTED_CONVERT_HANDLE)\r
1247  *\r
1248  * @return              0 on success, else a negative error value\r
1249  * @retval              DRM_TRUSTED_RETURN_SUCCESS on success\r
1250  * @retval              DRM_TRUSTED_RETURN_INVALID_ARG if arguments are invalid\r
1251  * @retval              DRM_TRUSTED_RETURN_COMMUNICATION_ERROR if socket error\r
1252  * @retval              DRM_TRUSTED_RETURN_INTERNAL_ERROR if operation error\r
1253  * @remarks\r
1254  * @see\r
1255  * @since       0.1\r
1256  */\r
1257 EXPORT_API int drm_trusted_write_convert(drm_trusted_write_conv_info_s *input,\r
1258                 drm_trusted_write_conv_resp_s *output,\r
1259                 DRM_TRUSTED_CONVERT_HANDLE hConvert)\r
1260 {\r
1261         /* Local Variables */\r
1262         drm_trusted_result_e result = DRM_TRUSTED_RETURN_SUCCESS;\r
1263         drm_trusted_request_data_s req_data;\r
1264         drm_trusted_response_data_s resp_data;\r
1265         int ret_comm = 0;\r
1266 \r
1267         /* memset the structures */\r
1268         memset(&req_data, 0x0, sizeof(drm_trusted_request_data_s));\r
1269         memset(&resp_data, 0x0, sizeof(drm_trusted_response_data_s));\r
1270 \r
1271         /* Check Input & Output Parameters */\r
1272         if (!input || !output || !hConvert) {\r
1273                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
1274                                 "Invalid Args, input = %p, output = %p, hConvert = %p",\r
1275                                 input, output, hConvert);\r
1276                 return DRM_TRUSTED_RETURN_INVALID_ARG;\r
1277         }\r
1278 \r
1279         DRM_TRUSTED_CLIENT_LOG("input = %p, output = %p, hConvert = %p",\r
1280                         input, output, hConvert);\r
1281 \r
1282         /* Copy the input to Request Structure */\r
1283         memcpy(req_data.fixed_data.request_data, input,\r
1284                         sizeof(drm_trusted_write_conv_info_s));\r
1285 \r
1286         /* Copy the handle into the request structure */\r
1287         req_data.fixed_data.hConvert = hConvert;\r
1288 \r
1289         /* Tell the server which API to be used */\r
1290         req_data.fixed_data.api_name = DRM_TRUSTED_WRITE_CONVERT;\r
1291 \r
1292         /* Number of additional data items to be sent */\r
1293         /* Send items that is filled by application */\r
1294         if (!(input->data) || input->data_len == 0) {\r
1295                 DRM_TRUSTED_CLIENT_EXCEPTION( "Invalid Args, data = %p, data_len = %d",\r
1296                                 input->data, input->data_len);\r
1297                 return DRM_TRUSTED_RETURN_INVALID_ARG;\r
1298         } else {\r
1299                 req_data.fixed_data.num_data_items++;\r
1300         }\r
1301 \r
1302         /* Fill details pertaining to additional pointers to be sent */\r
1303         /* Copy data */\r
1304         req_data.fixed_data.data_length[0] = input->data_len;\r
1305         req_data.data_items[0] = (char*)malloc(req_data.fixed_data.data_length[0]);\r
1306         if (!req_data.data_items[0]) {\r
1307                 DRM_TRUSTED_CLIENT_EXCEPTION("Memory Allocation Error!, Buf = %p",\r
1308                                 req_data.data_items[0]);\r
1309                 goto ErrorExit;\r
1310         }\r
1311 \r
1312         memcpy(req_data.data_items[0], input->data,\r
1313                         input->data_len);\r
1314 \r
1315         /* Send Data to DRM server */\r
1316         /* Call the Client Communication API */\r
1317         if ((ret_comm = drm_trusted_client_comm(&req_data, &resp_data)) != 0) {\r
1318                 DRM_TRUSTED_CLIENT_EXCEPTION("drm_trusted_client_comm error!!, ret_comm = %d",\r
1319                                 ret_comm);\r
1320                 result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
1321                 goto ErrorExit;\r
1322         }\r
1323 \r
1324         /* Copy the response obtained from the server into the output parameter */\r
1325         if (resp_data.fixed_data.resp_result != 0) {\r
1326                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
1327                                 "Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
1328                                 resp_data.fixed_data.resp_result);\r
1329                 result = resp_data.fixed_data.resp_result;\r
1330                 goto ErrorExit;\r
1331         } else {\r
1332                 DRM_TRUSTED_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x",\r
1333                                 resp_data.fixed_data.resp_result);\r
1334 \r
1335                 /* Copy the response from the server into output data */\r
1336                 memcpy(output, resp_data.fixed_data.response_data,\r
1337                                 sizeof(drm_trusted_write_conv_resp_s));\r
1338         }\r
1339 \r
1340 ErrorExit:\r
1341         /* Free Request data memory */\r
1342         for (int i = 0; i < req_data.fixed_data.num_data_items; i++) {\r
1343                 if (req_data.data_items[i])\r
1344                         free(req_data.data_items[i]);\r
1345         }\r
1346 \r
1347         if (result != DRM_TRUSTED_RETURN_SUCCESS) {\r
1348                 /* Failure */\r
1349                 DRM_TRUSTED_CLIENT_EXCEPTION("failed:result=0x%x", result);\r
1350                 return result;\r
1351         } else {\r
1352                 /* Success */\r
1353                 DRM_TRUSTED_CLIENT_LOG("Success:result=0x%x", result);\r
1354                 return result;\r
1355         }\r
1356 \r
1357 }\r
1358 \r
1359 /**\r
1360  * An application can release a resource for converting.\r
1361  *\r
1362  * @param[in]   hConvert        Pointer to Open Convert Handle(DRM_TRUSTED_CONVERT_HANDLE)\r
1363  *\r
1364  * @return              0 on success, else a negative error value\r
1365  * @retval              DRM_TRUSTED_RETURN_SUCCESS on success\r
1366  * @retval              DRM_TRUSTED_RETURN_INVALID_ARG if arguments are invalid\r
1367  * @retval              DRM_TRUSTED_RETURN_COMMUNICATION_ERROR if socket error\r
1368  * @retval              DRM_TRUSTED_RETURN_INTERNAL_ERROR if operation error\r
1369  * @remarks\r
1370  * @see\r
1371  * @since       0.1\r
1372  */\r
1373 EXPORT_API int drm_trusted_close_convert(DRM_TRUSTED_CONVERT_HANDLE *hConvert)\r
1374 {\r
1375         /* Local Variables */\r
1376         drm_trusted_result_e result = DRM_TRUSTED_RETURN_SUCCESS;\r
1377         drm_trusted_request_data_s req_data;\r
1378         drm_trusted_response_data_s resp_data;\r
1379         int ret_comm = 0;\r
1380 \r
1381         /* memset the structures */\r
1382         memset(&req_data, 0x0, sizeof(drm_trusted_request_data_s));\r
1383         memset(&resp_data, 0x0, sizeof(drm_trusted_response_data_s));\r
1384 \r
1385         /* Check Input & Output Parameters */\r
1386         if (!hConvert || !(*hConvert)) {\r
1387                 DRM_TRUSTED_CLIENT_EXCEPTION("Invalid Args, hConvert = %p, *hConvert = %p",\r
1388                                 hConvert, (!hConvert) ? NULL : *hConvert);\r
1389                 return DRM_TRUSTED_RETURN_INVALID_ARG;\r
1390         }\r
1391 \r
1392         DRM_TRUSTED_CLIENT_LOG("hConvert = %p, *hConvert = %p",\r
1393                         hConvert, *hConvert);\r
1394 \r
1395         /* Copy the handle into the request structure */\r
1396         req_data.fixed_data.hConvert = *hConvert;\r
1397 \r
1398         /* Tell the server which API to be used */\r
1399         req_data.fixed_data.api_name = DRM_TRUSTED_CLOSE_CONVERT;\r
1400 \r
1401         /* Send Data to DRM server */\r
1402         /* Call the Client Communication API */\r
1403         if ((ret_comm = drm_trusted_client_comm(&req_data, &resp_data)) != 0) {\r
1404                 DRM_TRUSTED_CLIENT_EXCEPTION("drm_trusted_client_comm error!!, ret_comm = %d",\r
1405                                 ret_comm);\r
1406                 result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
1407                 goto ErrorExit;\r
1408         }\r
1409 \r
1410         /* Copy the response obtained from the server into the output parameter */\r
1411         if (resp_data.fixed_data.resp_result != 0) {\r
1412                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
1413                                 "Error returned from server!!, resp_data.fixed_data.resp_result = 0x%x",\r
1414                                 resp_data.fixed_data.resp_result);\r
1415                 result = resp_data.fixed_data.resp_result;\r
1416                 goto ErrorExit;\r
1417         } else {\r
1418                 DRM_TRUSTED_CLIENT_LOG("resp_data.fixed_data.resp_result = 0x%x",\r
1419                                 resp_data.fixed_data.resp_result);\r
1420         }\r
1421 \r
1422 ErrorExit:\r
1423         if (result != DRM_TRUSTED_RETURN_SUCCESS) {\r
1424                 /* Failure */\r
1425                 DRM_TRUSTED_CLIENT_EXCEPTION("failed:result=0x%x", result);\r
1426                 return result;\r
1427         } else {\r
1428                 /* Success */\r
1429                 DRM_TRUSTED_CLIENT_LOG("Success:result=0x%x", result);\r
1430                 return result;\r
1431         }\r
1432 }\r