src/package_archive_info.c

   1 /*
   2  * Copyright (c) 2017 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 <stdlib.h>
  18
  19 #include <pkgmgr-info.h>
  20
  21 #include "package_archive_info.h"
  22 #include "package_manager.h"
  23 #include "package_manager_internal.h"
  24
  25 struct package_archive_info_s {
  26         pkgmgrinfo_archiveinfo_h archive_info;
  27 };
  28
  29 API int package_archive_info_create(const char *path,
  30                 package_archive_info_h *archive_info)
  31 {
  32         int ret;
  33         pkgmgrinfo_archiveinfo_h info;
  34         struct package_archive_info_s *info_out;
  35
  36         if (path == NULL || archive_info == NULL) {
  37                 _LOGE("Invalid parameter");
  38                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
  39         }
  40
  41         ret = pkgmgrinfo_archiveinfo_get_archiveinfo(path, &info);
  42         if (ret != PMINFO_R_OK) {
  43                 _LOGE("Failed to get archive info from %s", path);
  44                 return PACKAGE_MANAGER_ERROR_IO_ERROR;
  45         }
  46
  47         info_out = malloc(sizeof(struct package_archive_info_s));
  48         if (info_out == NULL) {
  49                 _LOGE("Out of memory");
  50                 pkgmgrinfo_archiveinfo_destroy_archiveinfo(info);
  51                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
  52         }
  53
  54         info_out->archive_info = info;
  55         *archive_info = info_out;
  56
  57         return PACKAGE_MANAGER_ERROR_NONE;
  58 }
  59
  60 API int package_archive_info_destroy(package_archive_info_h archive_info)
  61 {
  62         int ret;
  63         struct package_archive_info_s *info =
  64                 (struct package_archive_info_s *)archive_info;
  65
  66         if (archive_info == NULL) {
  67                 _LOGE("Invalid parameter");
  68                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
  69         }
  70
  71         ret = pkgmgrinfo_archiveinfo_destroy_archiveinfo(info->archive_info);
  72         if (ret != PMINFO_R_OK)
  73                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
  74         free(info);
  75
  76         return PACKAGE_MANAGER_ERROR_NONE;
  77 }
  78
  79 API int package_archive_info_get_package(package_archive_info_h archive_info,
  80                 char **package)
  81 {
  82         int ret;
  83         struct package_archive_info_s *info =
  84                 (struct package_archive_info_s *)archive_info;
  85         const char *pkgid;
  86
  87         if (archive_info == NULL || package == NULL) {
  88                 _LOGE("Invalid parameter");
  89                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
  90         }
  91
  92         ret = pkgmgrinfo_archiveinfo_get_pkgid(info->archive_info, &pkgid);
  93         if (ret != PMINFO_R_OK)
  94                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
  95
  96         *package = strdup(pkgid);
  97         if (*package == NULL) {
  98                 _LOGE("Out of memory");
  99                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 100         }
 101
 102         return PACKAGE_MANAGER_ERROR_NONE;
 103 }
 104
 105 API int package_archive_info_get_type(package_archive_info_h archive_info,
 106                 char **type)
 107 {
 108         int ret;
 109         struct package_archive_info_s *info =
 110                 (struct package_archive_info_s *)archive_info;
 111         const char *pkg_type;
 112
 113         if (archive_info == NULL || type == NULL) {
 114                 _LOGE("Invalid parameter");
 115                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 116         }
 117
 118         ret = pkgmgrinfo_archiveinfo_get_type(info->archive_info,
 119                         &pkg_type);
 120         if (ret != PMINFO_R_OK)
 121                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 122
 123         *type = strdup(pkg_type);
 124         if (*type == NULL) {
 125                 _LOGE("Out of memory");
 126                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 127         }
 128
 129         return PACKAGE_MANAGER_ERROR_NONE;
 130 }
 131
 132 API int package_archive_info_get_version(package_archive_info_h archive_info,
 133                 char **version)
 134 {
 135         int ret;
 136                 struct package_archive_info_s *info =
 137                 (struct package_archive_info_s *)archive_info;
 138         const char *pkg_version;
 139
 140         if (archive_info == NULL || version == NULL) {
 141                 _LOGE("Invalid parameter");
 142                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 143         }
 144
 145         ret = pkgmgrinfo_archiveinfo_get_version(info->archive_info,
 146                         &pkg_version);
 147         if (ret != PMINFO_R_OK)
 148                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 149
 150         *version = strdup(pkg_version);
 151         if (*version == NULL) {
 152                 _LOGE("Out of memory");
 153                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 154         }
 155
 156         return PACKAGE_MANAGER_ERROR_NONE;
 157 }
 158
 159 API int package_archive_info_get_api_version(
 160                 package_archive_info_h archive_info, char **api_version)
 161 {
 162         int ret;
 163         struct package_archive_info_s *info =
 164                 (struct package_archive_info_s *)archive_info;
 165         const char *pkg_api_version;
 166
 167         if (archive_info == NULL || api_version == NULL) {
 168                 _LOGE("Invalid parameter");
 169                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 170         }
 171
 172         ret = pkgmgrinfo_archiveinfo_get_api_version(info->archive_info,
 173                         &pkg_api_version);
 174         if (ret != PMINFO_R_OK)
 175                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 176
 177         *api_version = strdup(pkg_api_version);
 178         if (*api_version == NULL) {
 179                 _LOGE("Out of memory");
 180                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 181         }
 182
 183         return PACKAGE_MANAGER_ERROR_NONE;
 184 }
 185
 186 API int package_archive_info_get_description(
 187                 package_archive_info_h archive_info, char **description)
 188 {
 189         int ret;
 190         struct package_archive_info_s *info =
 191                 (struct package_archive_info_s *)archive_info;
 192         const char *pkg_description;
 193
 194         if (archive_info == NULL || description == NULL) {
 195                 _LOGE("Invalid parameter");
 196                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 197         }
 198
 199         ret = pkgmgrinfo_archiveinfo_get_description(info->archive_info,
 200                         &pkg_description);
 201         if (ret != PMINFO_R_OK)
 202                 return PACKAGE_MANAGER_ERROR_IO_ERROR;
 203
 204         *description = strdup(pkg_description);
 205         if (*description == NULL) {
 206                 _LOGE("Out of memory");
 207                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 208         }
 209
 210         return PACKAGE_MANAGER_ERROR_NONE;
 211 }
 212
 213 API int package_archive_info_get_label(package_archive_info_h archive_info,
 214                 char **label)
 215 {
 216         int ret;
 217         struct package_archive_info_s *info =
 218                 (struct package_archive_info_s *)archive_info;
 219         const char *pkg_label;
 220
 221         if (archive_info == NULL || label == NULL) {
 222                 _LOGE("Invalid parameter");
 223                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 224         }
 225
 226         ret = pkgmgrinfo_archiveinfo_get_label(info->archive_info,
 227                         &pkg_label);
 228         if (ret != PMINFO_R_OK)
 229                 return PACKAGE_MANAGER_ERROR_IO_ERROR;
 230
 231         *label = strdup(pkg_label);
 232         if (*label == NULL) {
 233                 _LOGE("Out of memory");
 234                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 235         }
 236
 237         return PACKAGE_MANAGER_ERROR_NONE;
 238 }
 239
 240 API int package_archive_info_get_author(package_archive_info_h archive_info,
 241                 char **author)
 242 {
 243         int ret;
 244         struct package_archive_info_s *info =
 245                 (struct package_archive_info_s *)archive_info;
 246         const char *pkg_author;
 247
 248         if (archive_info == NULL || author == NULL) {
 249                 _LOGE("Invalid parameter");
 250                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 251         }
 252
 253         ret = pkgmgrinfo_archiveinfo_get_author(info->archive_info,
 254                         &pkg_author);
 255         if (ret != PMINFO_R_OK)
 256                 return PACKAGE_MANAGER_ERROR_IO_ERROR;
 257
 258         *author = strdup(pkg_author);
 259         if (*author == NULL) {
 260                 _LOGE("Out of memory");
 261                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 262         }
 263
 264         return PACKAGE_MANAGER_ERROR_NONE;
 265 }
 266
 267 API int package_archive_info_get_icon(package_archive_info_h archive_info,
 268                 unsigned char **icon, size_t *icon_size)
 269 {
 270         int ret;
 271         struct package_archive_info_s *info =
 272                 (struct package_archive_info_s *)archive_info;
 273         const unsigned char *pkg_icon;
 274         size_t pkg_icon_size;
 275         unsigned char *icon_buf;
 276
 277         if (archive_info == NULL || icon == NULL || icon_size == NULL) {
 278                 _LOGE("Invalid parameter");
 279                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 280         }
 281
 282         ret = pkgmgrinfo_archiveinfo_get_icon(info->archive_info,
 283                         &pkg_icon, &pkg_icon_size);
 284         if (ret != PMINFO_R_OK)
 285                 return PACKAGE_MANAGER_ERROR_IO_ERROR;
 286
 287         icon_buf = malloc(pkg_icon_size * sizeof(unsigned char));
 288         if (icon_buf == NULL) {
 289                 _LOGE("Out of memory");
 290                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 291         }
 292
 293         memcpy(icon_buf, pkg_icon, pkg_icon_size);
 294         *icon = icon_buf;
 295         *icon_size = pkg_icon_size;
 296
 297         return PACKAGE_MANAGER_ERROR_NONE;
 298 }