src/package_manager.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 <stdlib.h>
  18 #include <string.h>
  19 #include <glib.h>
  20 #include <unistd.h>
  21
  22 #include <package-manager.h>
  23 #include <pkgmgr_installer.h>
  24 #include <pkgmgr-info.h>
  25 #include <tzplatform_config.h>
  26
  27 #include "package_manager.h"
  28 #include "package_manager_internal.h"
  29
  30 static GHashTable *__cb_table = NULL;
  31
  32 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
  33 typedef struct _event_info {
  34         int req_id;
  35         package_manager_event_type_e event_type;
  36         package_manager_event_state_e event_state;
  37         struct _event_info *next;
  38 } event_info;
  39
  40 struct package_manager_s {
  41         int handle_id;
  42         client_type ctype;
  43         pkgmgr_client *pc;
  44         pkgmgr_mode mode;
  45         event_info *head;
  46         package_manager_event_cb event_cb;
  47         package_manager_global_event_cb global_event_cb;
  48         void *user_data;
  49 };
  50
  51 struct package_manager_request_s {
  52         int handle_id;
  53         client_type ctype;
  54         pkgmgr_client *pc;
  55         const char *pkg_type;
  56         const char *pkg_path;
  57         const char *pkg_name;
  58         pkgmgr_mode mode;
  59         event_info *head;
  60         package_manager_request_event_cb event_cb;
  61         void *user_data;
  62 };
  63
  64 struct package_manager_filter_s {
  65         pkgmgrinfo_pkginfo_filter_h pkgmgrinfo_pkginfo_filter;
  66 };
  67
  68 static int package_manager_request_new_id()
  69 {
  70         static int request_handle_id = 0;
  71         return request_handle_id++;
  72 }
  73
  74 static int package_manager_new_id()
  75 {
  76         static int manager_handle_id = 0;
  77         return manager_handle_id++;
  78 }
  79
  80 API int package_manager_request_create(package_manager_request_h *request)
  81 {
  82         struct package_manager_request_s *package_manager_request;
  83
  84         if (request == NULL) {
  85                 return
  86                     package_manager_error
  87                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
  88                      NULL);
  89         }
  90
  91         package_manager_request =
  92             calloc(1, sizeof(struct package_manager_request_s));
  93         if (package_manager_request == NULL) {
  94                 return
  95                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
  96                                           __FUNCTION__,
  97                                           "failed to create a package_manager handle");
  98         }
  99
 100         package_manager_request->ctype = PC_REQUEST;
 101         package_manager_request->pc = pkgmgr_client_new(PC_REQUEST);
 102         if (package_manager_request->pc == NULL) {
 103                 free(package_manager_request);
 104                 return
 105                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 106                                           __FUNCTION__,
 107                                           "failed to create a package_manager client");
 108         }
 109
 110         package_manager_request->handle_id = package_manager_request_new_id();
 111
 112         *request = package_manager_request;
 113
 114         return PACKAGE_MANAGER_ERROR_NONE;
 115 }
 116
 117 static int package_manager_client_validate_handle(package_manager_request_h
 118                                                  request)
 119 {
 120         if (request == NULL || request->pc == NULL) {
 121                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 122         }
 123
 124         return PACKAGE_MANAGER_ERROR_NONE;
 125 }
 126
 127 API int package_manager_request_destroy(package_manager_request_h request)
 128 {
 129         if (package_manager_client_validate_handle(request)) {
 130                 return
 131                     package_manager_error
 132                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 133                      NULL);
 134         }
 135
 136         pkgmgr_client_free(request->pc);
 137         request->pc = NULL;
 138         free(request);
 139
 140         return PACKAGE_MANAGER_ERROR_NONE;
 141 }
 142
 143 API int package_manager_request_set_event_cb(package_manager_request_h request,
 144                                          package_manager_request_event_cb
 145                                          callback, void *user_data)
 146 {
 147
 148         int retval;
 149         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 150         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 151                 return retval;
 152
 153         if (package_manager_client_validate_handle(request)) {
 154                 return
 155                     package_manager_error
 156                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 157                      NULL);
 158         }
 159
 160         request->event_cb = callback;
 161         request->user_data = user_data;
 162
 163         return PACKAGE_MANAGER_ERROR_NONE;
 164 }
 165
 166 API int package_manager_request_unset_event_cb(package_manager_request_h request)
 167 {
 168         // TODO: Please implement this function.
 169         if (package_manager_client_validate_handle(request)) {
 170                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 171         }
 172
 173         return PACKAGE_MANAGER_ERROR_NONE;
 174 }
 175
 176
 177 API int package_manager_request_set_type(package_manager_request_h request,
 178                                      const char *pkg_type)
 179 {
 180         if (package_manager_client_validate_handle(request)) {
 181                 return
 182                     package_manager_error
 183                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 184                      NULL);
 185         }
 186
 187         request->pkg_type = pkg_type;
 188
 189         return PACKAGE_MANAGER_ERROR_NONE;
 190 }
 191
 192 API int package_manager_request_set_mode(package_manager_request_h request,
 193                                      package_manager_request_mode_e mode)
 194 {
 195         if (package_manager_client_validate_handle(request)) {
 196                 return
 197                     package_manager_error
 198                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 199                      NULL);
 200         }
 201
 202         if (mode == PACKAGE_MANAGER_REQUEST_MODE_QUIET)
 203                 request->mode = PM_QUIET;
 204         else
 205                 request->mode = PM_DEFAULT;
 206
 207         return PACKAGE_MANAGER_ERROR_NONE;
 208 }
 209
 210 static int package_manager_get_event_type(const char *key,
 211                                           package_manager_event_type_e *
 212                                           event_type)
 213 {
 214         if (key == NULL)
 215                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 216
 217         if (strcasecmp(key, PKGMGR_INSTALLER_INSTALL_EVENT_STR) == 0)
 218                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_INSTALL;
 219         else if (strcasecmp(key, PKGMGR_INSTALLER_UNINSTALL_EVENT_STR) == 0)
 220                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UNINSTALL;
 221         else if (strcasecmp(key, PKGMGR_INSTALLER_UPGRADE_EVENT_STR) == 0)
 222                 *event_type = PACKAGE_MANAGER_EVENT_TYPE_UPDATE;
 223         else
 224                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 225
 226         return PACKAGE_MANAGER_ERROR_NONE;
 227 }
 228
 229 static int __add_event_info(event_info ** head, int req_id,
 230                             package_manager_event_type_e event_type,
 231                             package_manager_event_state_e event_state)
 232 {
 233         event_info *evt_info;
 234         event_info *current;
 235         event_info *prev;
 236
 237         evt_info = (event_info *) calloc(1, sizeof(event_info));
 238         if (evt_info == NULL) {
 239                 _LOGD("calloc failed");
 240                 return -1;
 241         }
 242         evt_info->req_id = req_id;
 243         evt_info->event_type = event_type;
 244         evt_info->next = NULL;
 245
 246         if (*head == NULL)
 247                 *head = evt_info;
 248         else {
 249                 current = prev = *head;
 250                 while (current) {
 251                         prev = current;
 252                         current = current->next;
 253                 }
 254
 255                 prev->next = evt_info;
 256         }
 257
 258         return 0;
 259 }
 260
 261 static int __find_event_info(event_info ** head, int req_id,
 262                              package_manager_event_type_e * event_type,
 263                              package_manager_event_state_e * event_state)
 264 {
 265         event_info *tmp;
 266
 267         tmp = *head;
 268
 269         if (tmp == NULL) {
 270                 _LOGE("tmp is NULL");
 271                 return -1;
 272         }
 273
 274         _LOGD("tmp->req_id %d, event_type %d", tmp->req_id, event_type);
 275
 276         while (tmp) {
 277                 if (tmp->req_id == req_id) {
 278                         *event_type = tmp->event_type;
 279                         return 0;
 280                 }
 281                 tmp = tmp->next;
 282         }
 283         return -1;
 284 }
 285
 286 static int __update_event_info(event_info ** head, int req_id,
 287                                package_manager_event_type_e event_type,
 288                                package_manager_event_state_e event_state)
 289 {
 290         package_manager_event_type_e evt_type;
 291         package_manager_event_state_e evt_state;
 292         event_info *tmp;
 293
 294         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 295                 __add_event_info(head, req_id, event_type, event_state);
 296         else {
 297                 tmp = *head;
 298
 299                 if (tmp == NULL) {
 300                         _LOGE("tmp is NULL");
 301                         return -1;
 302                 }
 303
 304                 while (tmp) {
 305                         if (tmp->req_id == req_id) {
 306                                 tmp->event_type = event_type;
 307                                 return 0;
 308                         }
 309                         tmp = tmp->next;
 310                 }
 311         }
 312
 313         return -1;
 314 }
 315
 316 /*
 317 static int __remove_event_info(event_info **head request, int req_id)
 318 {
 319         event_info *current;
 320         event_info *tmp;
 321
 322         if (* == NULL)
 323                 return -1;
 324
 325         current = *head;
 326         while (current) {
 327                 if (current->next) {
 328                         if (current->next->req_id == req_id) {
 329                                 tmp = current->next;
 330                                 current->next = current->next->next;
 331                                 free(tmp);
 332                                 return 0;
 333                         }
 334                 }
 335                 tmp = tmp->next;
 336         }
 337
 338         return -1;
 339 }
 340 */
 341
 342 static int request_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
 343                                  const char *pkg_name, const char *key,
 344                                  const char *val, const void *pmsg, void *data)
 345 {
 346         int ret = -1;
 347         package_manager_event_type_e event_type = -1;
 348         package_manager_event_state_e event_state = -1;
 349
 350         _LOGD("request_event_handler is called");
 351
 352         package_manager_request_h request = data;
 353
 354         if (strcasecmp(key, "start") == 0) {
 355                 ret = package_manager_get_event_type(val, &event_type);
 356                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 357                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 358
 359                 __add_event_info(&(request->head), req_id, event_type,
 360                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 361
 362                 if (request->event_cb)
 363                         request->event_cb(req_id, pkg_type, pkg_name,
 364                                           event_type,
 365                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 366                                           0, PACKAGE_MANAGER_ERROR_NONE, request->user_data);
 367
 368         } else if (strcasecmp(key, "install_percent") == 0
 369                    || strcasecmp(key, "progress_percent") == 0) {
 370                 if (__find_event_info
 371                     (&(request->head), req_id, &event_type,
 372                      &event_state) == 0) {
 373                         __update_event_info(&(request->head), req_id,
 374                                             event_type,
 375                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 376                         if (request->event_cb)
 377                                 request->event_cb(req_id, pkg_type, pkg_name,
 378                                                   event_type,
 379                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 380                                                   atoi(val),
 381                                                   PACKAGE_MANAGER_ERROR_NONE,
 382                                                   request->user_data);
 383                 }
 384
 385         } else if (strcasecmp(key, "error") == 0) {
 386                 if (strcasecmp(key, "0") != 0) {
 387                         if (__find_event_info
 388                             (&(request->head), req_id, &event_type,
 389                              &event_state) == 0) {
 390                                 __update_event_info(&(request->head), req_id,
 391                                                     event_type,
 392                                                     PACKAGE_MANAGER_EVENT_STATE_FAILED);
 393                         }
 394
 395                         if (request->event_cb)
 396                                 request->event_cb(req_id, pkg_type,
 397                                                   pkg_name, event_type,
 398                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 399                                                   0,
 400                                                   PACKAGE_MANAGER_ERROR_NONE,
 401                                                   request->user_data);
 402
 403                 }
 404         } else if (strcasecmp(key, "end") == 0) {
 405                 if (__find_event_info
 406                     (&(request->head), req_id, &event_type,
 407                      &event_state) == 0) {
 408                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 409                                 if (request->event_cb)
 410                                         request->event_cb(req_id, pkg_type,
 411                                                           pkg_name, event_type,
 412                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 413                                                           100,
 414                                                           PACKAGE_MANAGER_ERROR_NONE,
 415                                                           request->user_data);
 416                         }
 417                 } else {
 418                         if (strcasecmp(key, "ok") != 0)
 419                                 if (request->event_cb)
 420                                         request->event_cb(req_id, pkg_type,
 421                                                           pkg_name, event_type,
 422                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 423                                                           0,
 424                                                           PACKAGE_MANAGER_ERROR_NONE,
 425                                                           request->user_data);
 426                 }
 427         }
 428
 429         return PACKAGE_MANAGER_ERROR_NONE;
 430 }
 431
 432 API int package_manager_request_install(package_manager_request_h request,
 433                                     const char *path, int *id)
 434 {
 435
 436         int retval;
 437         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 438         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 439                 return retval;
 440
 441         if (package_manager_client_validate_handle(request)) {
 442                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 443         }
 444         if (path == NULL) {
 445                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 446         }
 447
 448         int request_id = 0;
 449         request->pkg_path = path;
 450         uid_t uid = getuid();
 451         if (uid != GLOBAL_USER)
 452                 request_id = pkgmgr_client_usr_install(request->pc, request->pkg_type, NULL,
 453                                                         request->pkg_path, NULL,
 454                                                         request->mode, request_event_handler,
 455                                                         request,
 456                                                         uid);
 457         else
 458                 request_id = pkgmgr_client_install(request->pc, request->pkg_type, NULL,
 459                                                         request->pkg_path, NULL,
 460                                                         request->mode, request_event_handler,
 461                                                         request);
 462
 463         if (request_id == PKGMGR_R_EINVAL) {
 464                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 465         } else if (request_id == PKGMGR_R_ENOPKG) {
 466                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 467         } else if (request_id == PKGMGR_R_ENOMEM) {
 468                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 469         } else if (request_id == PKGMGR_R_EIO) {
 470                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 471         } else if (request_id == PKGMGR_R_EPRIV) {
 472                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 473         } else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR) {
 474                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 475         }
 476
 477         *id = request_id;
 478
 479         return PACKAGE_MANAGER_ERROR_NONE;
 480 }
 481
 482 API int package_manager_request_uninstall(package_manager_request_h request,
 483                                       const char *name, int *id)
 484 {
 485
 486         int retval;
 487         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 488         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 489                 return retval;
 490
 491         if (package_manager_client_validate_handle(request)) {
 492                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 493         }
 494         if (name == NULL) {
 495                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 496         }
 497
 498         int request_id = 0;
 499         request->pkg_name = name;
 500         uid_t uid = getuid();
 501         if (uid != GLOBAL_USER)
 502                 request_id = pkgmgr_client_usr_uninstall(request->pc, request->pkg_type,
 503                                                                 request->pkg_name, request->mode,
 504                                                                 request_event_handler, request, uid);
 505         else
 506                 request_id = pkgmgr_client_uninstall(request->pc, request->pkg_type,
 507                                                                 request->pkg_name, request->mode,
 508                                                                 request_event_handler, request);
 509
 510         if (request_id == PKGMGR_R_EINVAL) {
 511                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 512         } else if (request_id == PKGMGR_R_ENOPKG) {
 513                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 514         } else if (request_id == PKGMGR_R_ENOMEM) {
 515                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 516         } else if (request_id == PKGMGR_R_EIO) {
 517                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 518         } else if (request_id == PKGMGR_R_EPRIV) {
 519                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 520         } else if (request_id == PKGMGR_R_ESYSTEM || request_id == PKGMGR_R_ECOMM || request_id == PKGMGR_R_ERROR) {
 521                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 522         }
 523
 524         *id = request_id;
 525
 526         return PACKAGE_MANAGER_ERROR_NONE;
 527 }
 528
 529 API int package_manager_request_move(package_manager_request_h request,
 530                                     const char *name, package_manager_move_type_e move_type)
 531 {
 532
 533         int retval;
 534         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 535         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 536                 return retval;
 537
 538         if (package_manager_client_validate_handle(request)) {
 539                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 540         }
 541         if (name == NULL) {
 542                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 543         }
 544
 545         int ret = 0;
 546         request->pkg_name = name;
 547         uid_t uid = getuid();
 548         if (uid != GLOBAL_USER)
 549                 ret = pkgmgr_client_usr_move(request->pc, request->pkg_type, request->pkg_name,
 550                                                         move_type, request->mode, uid);
 551         else
 552                 ret = pkgmgr_client_move(request->pc, request->pkg_type, request->pkg_name,
 553                                                         move_type, request->mode);
 554         if (ret == PKGMGR_R_EINVAL) {
 555                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 556         } else if (ret == PKGMGR_R_ENOPKG) {
 557                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 558         } else if (ret == PKGMGR_R_ENOMEM) {
 559                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 560         } else if (ret == PKGMGR_R_EIO) {
 561                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 562         } else if (ret == PKGMGR_R_EPRIV) {
 563                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
 564         } else if (ret == PKGMGR_R_ESYSTEM || ret == PKGMGR_R_ECOMM || ret == PKGMGR_R_ERROR) {
 565                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 566         }
 567
 568
 569         return PACKAGE_MANAGER_ERROR_NONE;
 570 }
 571
 572 API int package_manager_create(package_manager_h * manager)
 573 {
 574
 575         int retval;
 576         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 577         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 578                 return retval;
 579
 580         struct package_manager_s *package_manager = NULL;
 581
 582         if (manager == NULL) {
 583                 return
 584                     package_manager_error
 585                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 586                      NULL);
 587         }
 588
 589         package_manager = calloc(1, sizeof(struct package_manager_s));
 590         if (package_manager == NULL) {
 591                 return
 592                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 593                                           __FUNCTION__,
 594                                           "failed to create a package_manager handle");
 595         }
 596
 597         package_manager->ctype = PC_LISTENING;
 598         package_manager->pc = pkgmgr_client_new(PC_LISTENING);
 599         if (package_manager->pc == NULL) {
 600                 free(package_manager);
 601                 return
 602                     package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY,
 603                                           __FUNCTION__,
 604                                           "failed to create a package_manager client");
 605         }
 606
 607         package_manager->handle_id = package_manager_new_id();
 608
 609         *manager = package_manager;
 610
 611         return PACKAGE_MANAGER_ERROR_NONE;
 612 }
 613
 614 static int package_manager_validate_handle(package_manager_h manager)
 615 {
 616         if (manager == NULL || manager->pc == NULL) {
 617                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 618         }
 619
 620         return PACKAGE_MANAGER_ERROR_NONE;
 621 }
 622
 623 API int package_manager_destroy(package_manager_h manager)
 624 {
 625         if (package_manager_validate_handle(manager)) {
 626                 return
 627                     package_manager_error
 628                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 629                      NULL);
 630         }
 631
 632         pkgmgr_client_free(manager->pc);
 633         manager->pc = NULL;
 634         free(manager);
 635
 636         return PACKAGE_MANAGER_ERROR_NONE;
 637 }
 638
 639 static int __add_event(event_info ** head, int req_id,
 640                             package_manager_event_type_e event_type,
 641                             package_manager_event_state_e event_state)
 642 {
 643         event_info *evt_info;
 644
 645         evt_info = (event_info *) calloc(1, sizeof(event_info));
 646         if (evt_info == NULL) {
 647                 _LOGD("calloc failed");
 648                 return -1;
 649         }
 650         evt_info->req_id = req_id;
 651         evt_info->event_type = event_type;
 652         evt_info->next = NULL;
 653
 654         *head = evt_info;
 655
 656         return 0;
 657 }
 658
 659 static int __find_event(event_info ** head, int req_id,
 660                              package_manager_event_type_e * event_type,
 661                              package_manager_event_state_e * event_state)
 662 {
 663         event_info *tmp;
 664
 665         tmp = *head;
 666
 667         if (tmp == NULL) {
 668                 _LOGE("tmp is NULL");
 669                 return -1;
 670         }
 671
 672         *event_type = tmp->event_type;
 673         return 0;
 674 }
 675
 676 static int __update_event(event_info ** head, int req_id,
 677                                package_manager_event_type_e event_type,
 678                                package_manager_event_state_e event_state)
 679 {
 680         package_manager_event_type_e evt_type;
 681         package_manager_event_state_e evt_state;
 682         event_info *tmp;
 683
 684         if (__find_event_info(head, req_id, &evt_type, &evt_state) != 0)
 685                 __add_event_info(head, req_id, event_type, event_state);
 686         else {
 687                 tmp = *head;
 688
 689                 if (tmp == NULL) {
 690                         _LOGE("tmp is NULL");
 691                         return -1;
 692                 }
 693
 694                 tmp->event_type = event_type;
 695                 return 0;
 696         }
 697
 698         return -1;
 699 }
 700
 701 /* App Event Listening Policy:
 702  * +----------------+------------+---------------+------------------+
 703  * |Listener \ Type |Global Event|My User's Event|Other user's Event|
 704  * +----------------+------------+---------------+------------------+
 705  * |User Process App|   Grant    |     Grant     |      Deny        |
 706  * +----------------+------------+---------------+------------------+
 707  * |Platform module |   Grant    |     Grant     |      Grant       |
 708  * +----------------+------------+---------------+------------------+
 709  * UID assignment policy:
 710  * https://wiki.tizen.org/wiki/Security/User_and_group_ID_assignment_policy
 711  */
 712 #define REGULAR_USER 5000
 713 static int __validate_event_signal(uid_t target_uid)
 714 {
 715         uid_t self = getuid();
 716
 717         if (self == target_uid)
 718                 return 0;
 719
 720         if (self < REGULAR_USER)
 721                 return 0;
 722
 723         return -1;
 724 }
 725
 726 static int global_event_handler(uid_t target_uid, int req_id, const char *pkg_type,
 727                                 const char *pkg_name, const char *key,
 728                                 const char *val, const void *pmsg, void *data)
 729 {
 730         int ret = -1;
 731         package_manager_event_type_e event_type = -1;
 732         package_manager_event_state_e event_state = -1;
 733
 734         _LOGD("global_event_handler is called");
 735
 736         package_manager_h manager = data;
 737
 738         if (__validate_event_signal(target_uid))
 739                 return PACKAGE_MANAGER_ERROR_NONE;
 740
 741         if (strcasecmp(key, "start") == 0) {
 742                 ret = package_manager_get_event_type(val, &event_type);
 743                 if (ret != PACKAGE_MANAGER_ERROR_NONE)
 744                         return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 745
 746                 __add_event(&(manager->head), req_id, event_type,
 747                                  PACKAGE_MANAGER_EVENT_STATE_STARTED);
 748
 749                 if (manager->event_cb && getuid() == target_uid)
 750                         manager->event_cb(pkg_type, pkg_name,
 751                                           event_type,
 752                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 753                                           0, PACKAGE_MANAGER_ERROR_NONE, manager->user_data);
 754                 if (manager->global_event_cb)
 755                         manager->global_event_cb(target_uid, pkg_type, pkg_name,
 756                                           event_type,
 757                                           PACKAGE_MANAGER_EVENT_STATE_STARTED,
 758                                           0, PACKAGE_MANAGER_ERROR_NONE, manager->user_data);
 759
 760         } else if (strcasecmp(key, "install_percent") == 0
 761                    || strcasecmp(key, "progress_percent") == 0) {
 762                 if (__find_event
 763                     (&(manager->head), req_id, &event_type,
 764                      &event_state) == 0) {
 765                         __update_event(&(manager->head), req_id,
 766                                             event_type,
 767                                             PACKAGE_MANAGER_EVENT_STATE_PROCESSING);
 768                         if (manager->event_cb && getuid() == target_uid)
 769                                 manager->event_cb(pkg_type, pkg_name,
 770                                                   event_type,
 771                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 772                                                   atoi(val),
 773                                                   PACKAGE_MANAGER_ERROR_NONE,
 774                                                   manager->user_data);
 775                         if (manager->global_event_cb)
 776                                 manager->global_event_cb(target_uid, pkg_type, pkg_name,
 777                                                   event_type,
 778                                                   PACKAGE_MANAGER_EVENT_STATE_PROCESSING,
 779                                                   atoi(val),
 780                                                   PACKAGE_MANAGER_ERROR_NONE,
 781                                                   manager->user_data);
 782                 }
 783
 784         } else if (strcasecmp(key, "error") == 0) {
 785                 if (strcasecmp(key, "0") != 0) {
 786                         if (__find_event
 787                             (&(manager->head), req_id, &event_type,
 788                              &event_state) == 0) {
 789                                 __update_event(&(manager->head), req_id,
 790                                                     event_type,
 791                                                     PACKAGE_MANAGER_EVENT_STATE_FAILED);
 792                         }
 793
 794                         if (manager->event_cb && getuid() == target_uid)
 795                                 manager->event_cb(pkg_type,
 796                                                   pkg_name, event_type,
 797                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 798                                                   0,
 799                                                   PACKAGE_MANAGER_ERROR_NONE,
 800                                                   manager->user_data);
 801                         if (manager->global_event_cb)
 802                                 manager->global_event_cb(target_uid, pkg_type,
 803                                                   pkg_name, event_type,
 804                                                   PACKAGE_MANAGER_EVENT_STATE_FAILED,
 805                                                   0,
 806                                                   PACKAGE_MANAGER_ERROR_NONE,
 807                                                   manager->user_data);
 808                 }
 809         } else if (strcasecmp(key, "end") == 0) {
 810                 if (__find_event
 811                     (&(manager->head), req_id, &event_type,
 812                      &event_state) == 0) {
 813                         if (event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
 814                                 if (manager->event_cb && getuid() == target_uid)
 815                                         manager->event_cb(pkg_type,
 816                                                           pkg_name, event_type,
 817                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 818                                                           100,
 819                                                           PACKAGE_MANAGER_ERROR_NONE,
 820                                                           manager->user_data);
 821                                 if (manager->global_event_cb)
 822                                         manager->global_event_cb(target_uid, pkg_type,
 823                                                           pkg_name, event_type,
 824                                                           PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
 825                                                           100,
 826                                                           PACKAGE_MANAGER_ERROR_NONE,
 827                                                           manager->user_data);
 828                         }
 829                 } else {
 830                         if (strcasecmp(key, "ok") != 0) {
 831                                 if (manager->event_cb && getuid() == target_uid)
 832                                         manager->event_cb(pkg_type,
 833                                                           pkg_name, event_type,
 834                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 835                                                           0,
 836                                                           PACKAGE_MANAGER_ERROR_NONE,
 837                                                           manager->user_data);
 838                                 if (manager->global_event_cb)
 839                                         manager->global_event_cb(target_uid, pkg_type,
 840                                                           pkg_name, event_type,
 841                                                           PACKAGE_MANAGER_EVENT_STATE_FAILED,
 842                                                           0,
 843                                                           PACKAGE_MANAGER_ERROR_NONE,
 844                                                           manager->user_data);
 845                         }
 846                 }
 847         }
 848
 849         return PACKAGE_MANAGER_ERROR_NONE;
 850 }
 851
 852 API int package_manager_set_event_status(package_manager_h manager, int status_type)
 853 {
 854         int retval;
 855
 856         if (manager == NULL){
 857                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 858         }
 859
 860         retval = pkgmgrinfo_client_set_status_type(manager->pc, status_type);
 861
 862         if (retval < 0){
 863                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 864         }
 865
 866         return PACKAGE_MANAGER_ERROR_NONE;
 867 }
 868
 869 API int package_manager_set_event_cb(package_manager_h manager,
 870                                  package_manager_event_cb callback,
 871                                  void *user_data)
 872 {
 873
 874         int retval;
 875         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 876         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 877                 return retval;
 878
 879         if (package_manager_validate_handle(manager)) {
 880                 return
 881                     package_manager_error
 882                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 883                      NULL);
 884         }
 885
 886         manager->event_cb = callback;
 887         manager->user_data = user_data;
 888
 889     pkgmgr_client_listen_status(manager->pc, global_event_handler, manager);
 890
 891         return PACKAGE_MANAGER_ERROR_NONE;
 892 }
 893
 894 API int package_manager_unset_event_cb(package_manager_h manager)
 895 {
 896         if (manager == NULL) {
 897                 return
 898                     package_manager_error
 899                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 900                      NULL);
 901         }
 902
 903         // TODO: Please implement this function.
 904         return PACKAGE_MANAGER_ERROR_NONE;
 905 }
 906
 907 API int package_manager_set_global_event_cb(package_manager_h manager,
 908                                  package_manager_global_event_cb callback,
 909                                  void *user_data)
 910 {
 911
 912         int retval;
 913         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 914         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 915                 return retval;
 916
 917         if (package_manager_validate_handle(manager)) {
 918                 return
 919                     package_manager_error
 920                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 921                      NULL);
 922         }
 923
 924         if (getuid() >= REGULAR_USER) {
 925                 _LOGE("Regular user is not allowed for this api");
 926                 return PACKAGE_MANAGER_ERROR_PERMISSION_DENIED;
 927         }
 928
 929         manager->global_event_cb = callback;
 930         manager->user_data = user_data;
 931
 932     pkgmgr_client_listen_status(manager->pc, global_event_handler, manager);
 933
 934         return PACKAGE_MANAGER_ERROR_NONE;
 935 }
 936
 937 API int package_manager_unset_global_event_cb(package_manager_h manager)
 938 {
 939         if (manager == NULL) {
 940                 return
 941                     package_manager_error
 942                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
 943                      NULL);
 944         }
 945
 946         // TODO: Please implement this function.
 947         return PACKAGE_MANAGER_ERROR_NONE;
 948 }
 949
 950 API int package_manager_get_package_id_by_app_id(const char *app_id, char **package_id)
 951 {
 952         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
 953         int retval;
 954         char *pkg_id = NULL;
 955         char *pkg_id_dup = NULL;
 956
 957         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 958         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 959                 return retval;
 960
 961         if (app_id == NULL || package_id == NULL)
 962                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 963
 964         uid_t uid = getuid();
 965         if (uid != GLOBAL_USER)
 966         {
 967                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, uid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 968                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 969         } else
 970         {
 971                 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
 972                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 973         }
 974         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
 975         if (retval != PMINFO_R_OK)
 976         {
 977                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
 978         }
 979
 980         pkg_id_dup = strdup(pkg_id);
 981         if (pkg_id_dup == NULL)
 982         {
 983                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 984                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 985         }
 986
 987         *package_id = pkg_id_dup;
 988
 989         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
 990
 991         return PACKAGE_MANAGER_ERROR_NONE;
 992 }
 993
 994 API int package_manager_get_package_info(const char *package_id, package_info_h *package_info)
 995 {
 996         int retval;
 997         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
 998         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 999                 return retval;
1000
1001         retval = package_info_get_package_info(package_id, package_info);
1002
1003         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1004                 return package_manager_error(retval, __FUNCTION__, NULL);
1005         else
1006                 return PACKAGE_MANAGER_ERROR_NONE;
1007 }
1008
1009 API int package_manager_foreach_package_info(package_manager_package_info_cb callback,
1010                                         void *user_data)
1011 {
1012
1013         int retval;
1014         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1015         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1016                 return retval;
1017
1018         retval = package_info_foreach_package_info(callback, user_data);
1019
1020         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1021                 return package_manager_error(retval, __FUNCTION__, NULL);
1022         else
1023         {
1024                 return PACKAGE_MANAGER_ERROR_NONE;
1025         }
1026 }
1027
1028 API int package_manager_compare_package_cert_info(const char *lhs_package_id, const char *rhs_package_id, package_manager_compare_result_type_e *compare_result)
1029 {
1030         pkgmgrinfo_cert_compare_result_type_e result;
1031   uid_t uid = getuid();
1032
1033         if (lhs_package_id == NULL || rhs_package_id == NULL || compare_result == NULL)
1034                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1035         if (uid != GLOBAL_USER)
1036         {
1037                 if (pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(lhs_package_id, rhs_package_id, uid, &result) != PKGMGR_R_OK)
1038                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1039         } else
1040         {
1041                 if (pkgmgrinfo_pkginfo_compare_pkg_cert_info(lhs_package_id, rhs_package_id, &result) != PKGMGR_R_OK)
1042                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1043         }
1044         *compare_result = (package_manager_compare_result_type_e)result;
1045
1046         return PACKAGE_MANAGER_ERROR_NONE;
1047 }
1048
1049 API int package_manager_compare_app_cert_info(const char *lhs_app_id, const char *rhs_app_id, package_manager_compare_result_type_e *compare_result)
1050 {
1051         pkgmgrinfo_cert_compare_result_type_e result;
1052         uid_t uid = getuid();
1053
1054         if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL)
1055                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1056         if (uid != GLOBAL_USER)
1057         {
1058                 if (pkgmgrinfo_pkginfo_compare_usr_app_cert_info(lhs_app_id, rhs_app_id, uid, &result) != PKGMGR_R_OK)
1059                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1060         } else
1061         {
1062                 if (pkgmgrinfo_pkginfo_compare_app_cert_info(lhs_app_id, rhs_app_id, &result) != PKGMGR_R_OK)
1063                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1064         }
1065
1066         *compare_result = (package_manager_compare_result_type_e)result;
1067
1068         return PACKAGE_MANAGER_ERROR_NONE;
1069 }
1070
1071 API int package_manager_is_preload_package_by_app_id(const char *app_id, bool *preload)
1072 {
1073
1074         int retval;
1075         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1076         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1077                 return retval;
1078
1079         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo = NULL;
1080         pkgmgrinfo_pkginfo_h pkgmgrinfo_pkginfo = NULL;
1081
1082         char *pkg_id = NULL;
1083         bool is_preload = 0;
1084         uid_t uid = getuid();
1085         if (uid != GLOBAL_USER)
1086         {
1087                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, uid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1088                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1089         } else
1090   {
1091                 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1092                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1093   }
1094         retval = pkgmgrinfo_appinfo_get_pkgname(pkgmgrinfo_appinfo, &pkg_id);
1095         if (retval != PMINFO_R_OK)
1096         {
1097                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1098                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1099         }
1100         if (uid != GLOBAL_USER)
1101         {
1102                 if (pkgmgrinfo_pkginfo_get_usr_pkginfo(pkg_id, uid, &pkgmgrinfo_pkginfo) != PMINFO_R_OK)
1103                 {
1104                         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1105                         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1106                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1107                 }
1108         } else
1109         {
1110                 if (pkgmgrinfo_pkginfo_get_pkginfo(pkg_id, &pkgmgrinfo_pkginfo) != PMINFO_R_OK)
1111                 {
1112                         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1113                         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1114                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1115                 }
1116         }
1117         if (pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo, &is_preload) != PMINFO_R_OK)
1118         {
1119                 pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1120                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1121                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1122         }
1123
1124         if (is_preload)
1125                 *preload = 1;
1126         else
1127                 *preload = 0;
1128
1129         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1130         pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo);
1131
1132         return PACKAGE_MANAGER_ERROR_NONE;
1133 }
1134
1135 API int package_manager_get_permission_type(const char *app_id, package_manager_permission_type_e *permission_type)
1136 {
1137
1138         int retval;
1139         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1140         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1141                 return retval;
1142
1143         pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo =NULL;
1144         pkgmgrinfo_permission_type permission = 0;
1145         uid_t uid = getuid();
1146         if (uid != GLOBAL_USER)
1147         {
1148                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_id, uid, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1149                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1150         } else {
1151                 if (pkgmgrinfo_appinfo_get_appinfo(app_id, &pkgmgrinfo_appinfo) != PMINFO_R_OK)
1152                         return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1153         }
1154         retval = pkgmgrinfo_appinfo_get_permission_type(pkgmgrinfo_appinfo, &permission);
1155         if (retval != PMINFO_R_OK)
1156                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1157
1158         if (permission == PMINFO_PERMISSION_NORMAL)
1159                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1160         else if (permission == PMINFO_PERMISSION_SIGNATURE)
1161                 *permission_type = PACKAGE_MANAGER_PERMISSION_SIGNATURE;
1162         else if (permission == PMINFO_PERMISSION_PRIVILEGE)
1163                 *permission_type = PACKAGE_MANAGER_PERMISSION_PRIVILEGE;
1164         else
1165                 *permission_type = PACKAGE_MANAGER_PERMISSION_NORMAL;
1166
1167         pkgmgrinfo_appinfo_destroy_appinfo(pkgmgrinfo_appinfo);
1168         return PACKAGE_MANAGER_ERROR_NONE;
1169 }
1170
1171 API int package_manager_clear_cache_dir(const char *package_id)
1172 {
1173
1174         int retval;
1175         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_CACHE);
1176         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1177                 return retval;
1178
1179         int res = pkgmgr_client_usr_clear_cache_dir(package_id, getuid());
1180         if (res == PKGMGR_R_EINVAL)
1181         {
1182                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1183         }
1184         else if (res == PKGMGR_R_ENOPKG)
1185         {
1186                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1187         }
1188         else if (res == PKGMGR_R_ENOMEM)
1189         {
1190                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1191         }
1192         else if (res == PKGMGR_R_EIO)
1193         {
1194                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1195         }
1196         else if (res == PKGMGR_R_EPRIV)
1197         {
1198                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1199         }
1200         else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR)
1201         {
1202                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1203         }
1204         else if (res != PKGMGR_R_OK)
1205         {
1206                 _LOGE("Unexpected error");
1207                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1208         }
1209
1210         return PACKAGE_MANAGER_ERROR_NONE;
1211 }
1212
1213 API int package_manager_clear_all_cache_dir(void)
1214 {
1215
1216         int retval;
1217         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
1218         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1219                 return retval;
1220
1221         return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
1222 }
1223
1224 static void __initialize_cb_table(void)
1225 {
1226         __cb_table = g_hash_table_new_full(g_int_hash, g_int_equal, pkgmgr_client_free, NULL);
1227 }
1228
1229 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
1230 {
1231         package_manager_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1232         if (callback == NULL)
1233         {
1234                 _LOGE("callback is null.");
1235                 g_hash_table_remove(__cb_table, pc);
1236                 return;
1237         }
1238
1239         package_size_info_t size_info;
1240         size_info.data_size  = result->data_size;
1241         size_info.cache_size = result->cache_size;
1242         size_info.app_size   = result->app_size;
1243         size_info.external_data_size  = result->ext_data_size;
1244         size_info.external_cache_size = result->ext_cache_size;
1245         size_info.external_app_size   = result->ext_app_size;
1246
1247         callback(pkgid, &size_info, user_data);
1248
1249         g_hash_table_remove(__cb_table, pc);
1250 }
1251
1252 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
1253 {
1254         package_manager_total_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
1255         if (callback == NULL)
1256         {
1257                 _LOGE("callback is null.");
1258                 g_hash_table_remove(__cb_table, pc);
1259                 return;
1260         }
1261
1262         package_size_info_t size_info;
1263         size_info.data_size  = result->data_size;
1264         size_info.cache_size = result->cache_size;
1265         size_info.app_size   = result->app_size;
1266         size_info.external_data_size  = result->ext_data_size;
1267         size_info.external_cache_size = result->ext_cache_size;
1268         size_info.external_app_size   = result->ext_app_size;
1269
1270         callback(&size_info, user_data);
1271
1272         g_hash_table_remove(__cb_table, pc);
1273 }
1274
1275 API int package_manager_get_package_size_info(const char *package_id, package_manager_size_info_receive_cb callback, void *user_data)
1276 {
1277         if (package_id == NULL || callback == NULL)
1278         {
1279                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1280         }
1281
1282         if (__cb_table == NULL)
1283         {
1284                 __initialize_cb_table();
1285         }
1286
1287         pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
1288         if (pc == NULL)
1289         {
1290                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1291         }
1292
1293         int res = 0;
1294         if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
1295         {
1296                 res = pkgmgr_client_usr_get_package_size_info(pc, package_id, __result_cb, user_data, getuid());
1297         }
1298         else
1299         {
1300                 res = pkgmgr_client_usr_get_total_package_size_info(pc, __total_result_cb, user_data, getuid());
1301         }
1302
1303         if (res == PKGMGR_R_EINVAL)
1304         {
1305                 pkgmgr_client_free(pc);
1306                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1307         }
1308         else if (res == PKGMGR_R_ENOPKG)
1309         {
1310                 pkgmgr_client_free(pc);
1311                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
1312         }
1313         else if (res == PKGMGR_R_ENOMEM)
1314         {
1315                 pkgmgr_client_free(pc);
1316                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
1317         }
1318         else if (res == PKGMGR_R_EIO)
1319         {
1320                 pkgmgr_client_free(pc);
1321                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1322         }
1323         else if (res == PKGMGR_R_EPRIV)
1324         {
1325                 pkgmgr_client_free(pc);
1326                 return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
1327         }
1328         else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR)
1329         {
1330                 pkgmgr_client_free(pc);
1331                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1332         }
1333         else if (res != PKGMGR_R_OK)
1334         {
1335                 _LOGE("Unexpected error");
1336                 pkgmgr_client_free(pc);
1337                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
1338         }
1339
1340         g_hash_table_insert(__cb_table, pc, callback);
1341
1342         _LOGD("Successful");
1343         return PACKAGE_MANAGER_ERROR_NONE;
1344 }
1345
1346 API int package_manager_get_total_package_size_info(package_manager_total_size_info_receive_cb callback, void *user_data)
1347 {
1348         return package_manager_get_package_size_info(PKG_SIZE_INFO_TOTAL, callback, user_data);
1349 }
1350
1351 API int package_manager_filter_create(package_manager_filter_h *handle)
1352 {
1353         int retval;
1354         pkgmgrinfo_pkginfo_filter_h pkgmgr_filter = NULL;
1355
1356         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1357         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1358                 return retval;
1359
1360         if (handle == NULL)
1361         {
1362                 return
1363                     package_manager_error
1364                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1365                      NULL);
1366         }
1367
1368         retval = pkgmgrinfo_pkginfo_filter_create(&pkgmgr_filter);
1369         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1370         {
1371                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1372         }
1373
1374         *handle = pkgmgr_filter;
1375
1376         return PACKAGE_MANAGER_ERROR_NONE;
1377 }
1378
1379 API int package_manager_filter_destroy(package_manager_filter_h handle)
1380 {
1381         int retval;
1382
1383         if (handle == NULL)
1384         {
1385                 return
1386                     package_manager_error
1387                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1388                      NULL);
1389         }
1390
1391         retval = pkgmgrinfo_pkginfo_filter_destroy(handle);
1392         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1393         {
1394                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1395         }
1396
1397         return PACKAGE_MANAGER_ERROR_NONE;
1398 }
1399
1400 API int package_manager_filter_add_bool(package_manager_filter_h handle,
1401                 const char *property, const bool value)
1402 {
1403         int retval;
1404
1405         if ((handle == NULL) || (property == NULL))
1406         {
1407                 return
1408                     package_manager_error
1409                     (PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__,
1410                      NULL);
1411         }
1412
1413         retval = pkgmgrinfo_pkginfo_filter_add_bool(handle, property, value);
1414         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1415         {
1416                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1417         }
1418
1419         return PACKAGE_MANAGER_ERROR_NONE;
1420 }
1421
1422 API int package_manager_filter_count(package_manager_filter_h handle, int *count)
1423 {
1424
1425         int retval;
1426         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1427         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1428                 return retval;
1429
1430         if ((handle == NULL) || (count == NULL))
1431         {
1432                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1433         }
1434
1435         retval = pkgmgrinfo_pkginfo_filter_count(handle, count);
1436         if (retval < 0)
1437         {
1438                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
1439         }
1440
1441         return PACKAGE_MANAGER_ERROR_NONE;
1442 }
1443
1444 API int package_manager_filter_foreach_package_info(package_manager_filter_h handle,
1445                 package_manager_package_info_cb callback, void *user_data)
1446 {
1447
1448         int retval;
1449         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_INFO);
1450         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1451                 return retval;
1452
1453         retval = package_info_filter_foreach_package_info(handle, callback, user_data);
1454
1455         if (retval != PACKAGE_MANAGER_ERROR_NONE)
1456         {
1457                 return package_manager_error(retval, __FUNCTION__, NULL);
1458         }
1459         else
1460         {
1461                 return PACKAGE_MANAGER_ERROR_NONE;
1462         }
1463 }
1464
1465 API int package_size_info_get_data_size(package_size_info_h handle, long long *data_size)
1466 {
1467         if (handle == NULL)
1468                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1469
1470         package_size_info_t *size_info = (package_size_info_t *)handle;
1471
1472         *data_size = (long long)size_info->data_size;
1473         return PACKAGE_MANAGER_ERROR_NONE;
1474 }
1475
1476 API int package_size_info_get_cache_size(package_size_info_h handle, long long *cache_size)
1477 {
1478         if (handle == NULL)
1479                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1480
1481         package_size_info_t *size_info = (package_size_info_t *)handle;
1482
1483         *cache_size = size_info->cache_size;
1484         return PACKAGE_MANAGER_ERROR_NONE;
1485 }
1486
1487 API int package_size_info_get_app_size(package_size_info_h handle, long long *app_size)
1488 {
1489         if (handle == NULL)
1490                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1491
1492         package_size_info_t *size_info = (package_size_info_t *)handle;
1493         *app_size = size_info->app_size;
1494         return PACKAGE_MANAGER_ERROR_NONE;
1495 }
1496
1497 API int package_size_info_get_external_data_size(package_size_info_h handle, long long *ext_data_size)
1498 {
1499         if (handle == NULL)
1500                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
1501
1502         package_size_info_t *size_info = (package_size_info_t *)handle;
1503         *ext_data_size = size_info->external_data_size;
1504         return PACKAGE_MANAGER_ERROR_NONE;
1505 }
1506
1507 API int package_size_info_get_external_cache_size(package_size_info_h handle, long long *ext_cache_size)
1508 {
1509         if (handle == NULL)
1510                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1511
1512         package_size_info_t *size_info = (package_size_info_t *)handle;
1513         *ext_cache_size = size_info->external_cache_size;
1514         return PACKAGE_MANAGER_ERROR_NONE;
1515 }
1516
1517 API int package_size_info_get_external_app_size(package_size_info_h handle, long long *ext_app_size)
1518 {
1519         if (handle == NULL)
1520                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
1521
1522         package_size_info_t *size_info = (package_size_info_t *)handle;
1523         *ext_app_size = size_info->external_app_size;
1524         return PACKAGE_MANAGER_ERROR_NONE;
1525 }