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