src/package_manager_drm.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <unistd.h>
  18
  19 #include <package-manager.h>
  20
  21 #include "package_manager.h"
  22 #include "package_manager_internal.h"
  23
  24 API int package_manager_drm_generate_license_request(const char *resp_data,
  25                 char **req_data, char **license_url)
  26 {
  27         int ret;
  28         pkgmgr_client *pc;
  29
  30         if (resp_data == NULL || req_data == NULL || license_url == NULL)
  31                 return package_manager_error(
  32                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
  33                                 __FUNCTION__, NULL);
  34
  35         pc = pkgmgr_client_new(PC_REQUEST);
  36         if (pc == NULL)
  37                 return package_manager_error(
  38                                 PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
  39                                 __FUNCTION__, NULL);
  40
  41         ret = pkgmgr_client_generate_license_request(pc, resp_data, req_data,
  42                         license_url);
  43         pkgmgr_client_free(pc);
  44         if (ret == PKGMGR_R_EINVAL) {
  45                 return package_manager_error(
  46                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
  47                                 __FUNCTION__, NULL);
  48         } else if (ret == PKGMGR_R_ENOMEM) {
  49                 return package_manager_error(
  50                                 PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
  51                                 __FUNCTION__, NULL);
  52         } else if (ret == PKGMGR_R_EPRIV) {
  53                 return package_manager_error(
  54                                 PACKAGE_MANAGER_ERROR_PERMISSION_DENIED,
  55                                 __FUNCTION__, NULL);
  56         } else if (ret != PKGMGR_R_OK) {
  57                 return package_manager_error(
  58                                 PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
  59                                 __FUNCTION__, NULL);
  60         }
  61
  62         return PACKAGE_MANAGER_ERROR_NONE;
  63 }
  64
  65 API int package_manager_drm_register_license(const char *resp_data)
  66 {
  67         int ret;
  68         pkgmgr_client *pc;
  69
  70         if (resp_data == NULL)
  71                 return package_manager_error(
  72                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
  73                                 __FUNCTION__, NULL);
  74
  75
  76         pc = pkgmgr_client_new(PC_REQUEST);
  77         if (pc == NULL)
  78                 return package_manager_error(
  79                                 PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
  80                                 __FUNCTION__, NULL);
  81
  82         ret = pkgmgr_client_register_license(pc, resp_data);
  83         pkgmgr_client_free(pc);
  84         if (ret == PKGMGR_R_EINVAL) {
  85                 return package_manager_error(
  86                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
  87                                 __FUNCTION__, NULL);
  88         } else if (ret == PKGMGR_R_ENOMEM) {
  89                 return package_manager_error(
  90                                 PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
  91                                 __FUNCTION__, NULL);
  92         } else if (ret == PKGMGR_R_EPRIV) {
  93                 return package_manager_error(
  94                                 PACKAGE_MANAGER_ERROR_PERMISSION_DENIED,
  95                                 __FUNCTION__, NULL);
  96         } else if (ret != PKGMGR_R_OK) {
  97                 return package_manager_error(
  98                                 PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
  99                                 __FUNCTION__, NULL);
 100         }
 101
 102         return PACKAGE_MANAGER_ERROR_NONE;
 103 }
 104
 105 API int package_manager_drm_decrypt_package(const char *drm_file_path,
 106                 const char *decrypted_file_path)
 107 {
 108         int ret;
 109         pkgmgr_client *pc;
 110
 111         if (drm_file_path == NULL || decrypted_file_path == NULL)
 112                 return package_manager_error(
 113                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
 114                                 __FUNCTION__, NULL);
 115
 116         pc = pkgmgr_client_new(PC_REQUEST);
 117         if (pc == NULL)
 118                 return package_manager_error(
 119                                 PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 120                                 __FUNCTION__, NULL);
 121
 122         ret = pkgmgr_client_decrypt_package(pc, drm_file_path,
 123                         decrypted_file_path);
 124         pkgmgr_client_free(pc);
 125         if (ret == PKGMGR_R_EINVAL) {
 126                 return package_manager_error(
 127                                 PACKAGE_MANAGER_ERROR_INVALID_PARAMETER,
 128                                 __FUNCTION__, NULL);
 129         } else if (ret == PKGMGR_R_ENOMEM) {
 130                 return package_manager_error(
 131                                 PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 132                                 __FUNCTION__, NULL);
 133         } else if (ret == PKGMGR_R_EPRIV) {
 134                 return package_manager_error(
 135                                 PACKAGE_MANAGER_ERROR_PERMISSION_DENIED,
 136                                 __FUNCTION__, NULL);
 137         } else if (ret != PKGMGR_R_OK) {
 138                 return package_manager_error(
 139                                 PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
 140                                 __FUNCTION__, NULL);
 141         }
 142
 143         return PACKAGE_MANAGER_ERROR_NONE;
 144 }