src/agent/download-agent-plugin-drm.c

   1 /*
   2  * Download Agent
   3  *
   4  * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jungki Kwak <jungki.kwak@samsung.com>, Keunsoon Lee <keunsoon.lee@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  * @file                download-agent-plugin-drm.c
  21  * @brief               Platform dependent functions for emerald DRM from SISO
  22  * @author              Keunsoon Lee(keunsoon.lee@samsung.com)
  23  ***/
  24
  25 #include <stdio.h>
  26 #include <unistd.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <drm_client.h>
  30 #include <drm_client_types.h>
  31 #include <drm_trusted_client.h>
  32 #include <drm_trusted_client_types.h>
  33 #include "download-agent-debug.h"
  34 #include "download-agent-plugin-drm.h"
  35
  36 da_bool_t EDRM_check_dcf_file(const char *file_path)
  37 {
  38         drm_file_info_s file_info;
  39         int ret = -1;
  40
  41         ret = drm_get_file_info(file_path, &file_info);
  42         if (ret != DRM_RETURN_SUCCESS)  {
  43                 DA_LOG(DRMManager,"error : ret[%d]\n", ret);
  44                 return DA_FALSE;
  45         }
  46
  47         if (file_info.oma_info.version == DRM_OMA_DRMV1_RIGHTS &&
  48                         (file_info.oma_info.method == DRM_METHOD_TYPE_COMBINED_DELIVERY ||
  49                         file_info.oma_info.method == DRM_METHOD_TYPE_SEPARATE_DELIVERY)) {
  50                 return DA_TRUE;
  51         } else {
  52                 return DA_FALSE;
  53         }
  54 }
  55
  56 da_bool_t EDRM_has_vaild_ro(const char *file_path)
  57 {
  58         int ret = -1;
  59         drm_license_status_e status = DRM_LICENSE_STATUS_UNDEFINED;
  60         ret = drm_get_license_status(file_path, DRM_PERMISSION_TYPE_ANY, &status);
  61
  62         if (status == DRM_LICENSE_STATUS_VALID)
  63                 return DA_TRUE;
  64         else
  65                 return DA_FALSE;
  66 }
  67
  68 da_bool_t EDRM_open_convert(const char *file_path, void **fd)
  69 {
  70         DRM_TRUSTED_CONVERT_HANDLE hConvert;
  71         drm_trusted_opn_conv_info_s input = {{0,},};
  72
  73         if (!file_path || !fd) {
  74                 DA_LOG_ERR(DRMManager,"Invalid paramter");
  75                 return DA_FALSE;
  76         }
  77         strncpy(input.filePath, file_path, sizeof(input.filePath) - 1);
  78         if (drm_trusted_open_convert(&input, &hConvert) < 0) {
  79                 DA_LOG_ERR(DRMManager,"Fail to open convert");
  80                 return DA_FALSE;
  81         }
  82         *fd = hConvert;
  83         return DA_TRUE;
  84 }
  85
  86 da_bool_t EDRM_write_convert(void *fd, unsigned char *buffer, int buffer_size)
  87 {
  88         DRM_TRUSTED_CONVERT_HANDLE hConvert;
  89         drm_trusted_write_conv_info_s input = {0,};
  90         drm_trusted_write_conv_resp_s output = {0,};
  91
  92         if (!fd || !buffer || buffer_size < 0) {
  93                 DA_LOG_ERR(DRMManager,"Invalid paramter");
  94                 return DA_FALSE;
  95         }
  96         hConvert = fd;
  97         input.data_len = buffer_size;
  98         input.data = buffer;
  99         if (drm_trusted_write_convert(&input,&output,fd) < 0) {
 100                 DA_LOG_ERR(DRMManager,"Fail to write convert");
 101                 return DA_FALSE;
 102         }
 103         if (buffer_size != output.write_size) {
 104                 DA_LOG_ERR(DRMManager,"written size is failed");
 105                 return DA_FALSE;
 106         }
 107         return DA_TRUE;
 108 }
 109
 110 da_bool_t EDRM_close_convert(void **fd)
 111 {
 112         DRM_TRUSTED_CONVERT_HANDLE hConvert;
 113         if (!fd) {
 114                 DA_LOG_ERR(DRMManager,"Invalid paramter");
 115                 return DA_FALSE;
 116         }
 117         hConvert = *fd;
 118         if (drm_trusted_close_convert(&hConvert) < 0) {
 119                 DA_LOG_ERR(DRMManager,"Fail to close convert");
 120                 return DA_FALSE;
 121         }
 122         return DA_TRUE;
 123 }
 124
 125 da_bool_t EDRM_http_user_cancel(void *roap_session)
 126 {
 127         return DA_FALSE;
 128 }
 129
 130 da_result_t EDRM_wm_get_license(char *rights_url, char **out_content_url)
 131 {
 132         drm_initiator_info_s init_info;
 133         drm_web_server_resp_data_s resp_data;
 134         int ret = 0;
 135         int len = 0;
 136
 137         if (rights_url == NULL)
 138                 return DA_ERR_DRM_FAIL;
 139
 140         memset(&init_info, 0, sizeof(init_info));
 141         memset(&resp_data, 0, sizeof(resp_data));
 142         strncpy(init_info.initiator_url, rights_url, DRM_MAX_LEN_INITIATOR_URL - 1);
 143         len = strlen(rights_url);
 144         if (len > DRM_MAX_LEN_INITIATOR_URL - 1)
 145                 init_info.initiator_url_len = (unsigned int)len;
 146         else
 147                 init_info.initiator_url_len = DRM_MAX_LEN_INITIATOR_URL;
 148         ret = drm_process_request(DRM_REQUEST_TYPE_SUBMIT_INITIATOR_URL,
 149                         &init_info, &resp_data);
 150         if (DRM_RETURN_SUCCESS == ret) {
 151                 DA_LOG(DRMManager,"resp_data.content_url = %s", resp_data.content_url);
 152                 /* Rights or Domain Certificate are installed successfully */
 153                 /* Check for contentURL */
 154                 if (strlen(resp_data.content_url) > 0) {
 155                         char *content_url = NULL;
 156                         size_t content_url_len = 0;
 157                         content_url_len = strlen(resp_data.content_url);
 158                         if (content_url_len == 0) {
 159                                 DA_LOG(DRMManager,"content_url is NULL. Join/Leave Domain, Metering case.");
 160                                 *out_content_url = DA_NULL;
 161                                 return DA_RESULT_OK;
 162                         } else {
 163                                 content_url = (char *)calloc(1, content_url_len + 1);
 164                                 if (content_url) {
 165                                         strncpy(content_url, resp_data.content_url,
 166                                                 content_url_len);
 167                                         *out_content_url =      content_url;
 168                                         DA_LOG(DRMManager,"drm sumitted initiator url "
 169                                                         "succeeded with [%s]", *out_content_url);
 170                                         return DA_RESULT_OK;
 171                                 } else {
 172                                         DA_LOG_ERR(DRMManager,"DA_ERR_FAIL_TO_MEMALLOC");
 173                                         return DA_ERR_FAIL_TO_MEMALLOC;
 174                                 }
 175                         }
 176                 } else {
 177                         DA_LOG_ERR(DRMManager,"resp_data.content url is NULL");
 178                         return DA_ERR_DRM_FAIL;
 179                 }
 180         } else {
 181                 DA_LOG_ERR(DRMManager,"drm_process_request() failed");
 182                 return DA_ERR_DRM_FAIL;
 183         }
 184 }
 185