installer/pkgmgr_installer.c

   1 /*
   2  * slp-pkgmgr
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
   7  * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26 #include <string.h>
  27 #include <errno.h>
  28 #include <getopt.h>
  29 #include <sys/types.h>
  30 #include <sys/socket.h>
  31 #include <sys/un.h>
  32
  33 #include <glib.h>
  34 #include <gio/gio.h>
  35 #include <tzplatform_config.h>
  36
  37 #include "pkgmgr_installer.h"
  38 #include "pkgmgr_installer_config.h"
  39 #include "pkgmgr_installer_debug.h"
  40 #include "pkgmgr_installer_info.h"
  41
  42 #include <pkgmgr-info.h>
  43
  44 /* API export macro */
  45 #ifndef API
  46 #define API __attribute__ ((visibility("default")))
  47 #endif
  48
  49 #define MAX_STRLEN 1024
  50 #define MAX_QUERY_LEN   4096
  51
  52 #define CHK_PI_RET(r) \
  53         do { if (NULL == pi) return (r); } while (0)
  54
  55 #define OPTVAL_PRELOAD 1000
  56 #define OPTVAL_FORCE_REMOVAL 1001
  57 #define OPTVAL_PRELOAD_RW 1002
  58 #define OPTVAL_NO_REMOVAL 1003
  59
  60 /* Supported options */
  61 const char *short_opts = "k:l:i:d:c:m:t:o:r:p:s:b:e:M:y:u:w:D:A:q";
  62 const struct option long_opts[] = {
  63         { "session-id", 1, NULL, 'k' },
  64         { "license-path", 1, NULL, 'l' },
  65         { "install", 1, NULL, 'i' },
  66         { "uninstall", 1, NULL, 'd' },
  67         { "clear", 1, NULL, 'c' },
  68         { "move", 1, NULL, 'm' },
  69         { "move-type", 1, NULL, 't' },
  70         { "optional-data", 0, NULL, 'o' },
  71         { "reinstall", 0, NULL, 'r' },
  72         { "caller-pkgid", 1, NULL, 'p' },
  73         { "tep-path", 1, NULL, 'e' },
  74         { "tep-move", 1, NULL, 'M' },
  75         { "smack", 1, NULL, 's' },
  76         { "direct-manifest-install", 1, NULL, 'y' },
  77         { "mount-install", 1, NULL, 'w' },
  78         { "recovery", 1, NULL, 'b' },
  79         { "preload", 0, NULL, OPTVAL_PRELOAD },
  80         { "force-remove", 0, NULL, OPTVAL_FORCE_REMOVAL },
  81         { "preload-rw", 0, NULL, OPTVAL_PRELOAD_RW },
  82         { "no-remove", 0, NULL, OPTVAL_NO_REMOVAL },
  83         { 0, 0, 0, 0 }  /* sentinel */
  84 };
  85
  86 struct pkgmgr_installer {
  87         int request_type;
  88         int move_type;
  89         char *pkgmgr_info;
  90         char *session_id;
  91         char *license_path;
  92         char *optional_data;
  93         char *caller_pkgid;
  94         uid_t target_uid;
  95         char *tep_path;
  96         int tep_move;
  97         int is_tep_included;
  98         int is_preload;
  99         int force_removal;
 100         int is_preload_rw;
 101         int no_removal;
 102         GDBusConnection *conn;
 103 };
 104
 105 static uid_t g_target_uid;
 106
 107 static const char *__get_signal_name(pkgmgr_installer *pi, const char *key)
 108 {
 109         if (strcmp(key, PKGMGR_INSTALLER_INSTALL_PERCENT_KEY_STR) == 0)
 110                 return key;
 111         else if (strcmp(key, PKGMGR_INSTALLER_GET_SIZE_KEY_STR) == 0)
 112                 return key;
 113         else if (strcmp(key, PKGMGR_INSTALLER_APPID_KEY_STR) == 0)
 114                 return PKGMGR_INSTALLER_UNINSTALL_EVENT_STR;
 115
 116         switch (pi->request_type) {
 117         case PKGMGR_REQ_INSTALL:
 118         case PKGMGR_REQ_MANIFEST_DIRECT_INSTALL:
 119         case PKGMGR_REQ_MOUNT_INSTALL:
 120         case PKGMGR_REQ_REINSTALL:
 121         case PKGMGR_REQ_ENABLE_PKG:
 122         case PKGMGR_REQ_RECOVER:
 123                 return PKGMGR_INSTALLER_INSTALL_EVENT_STR;
 124         case PKGMGR_REQ_UNINSTALL:
 125         case PKGMGR_REQ_DISABLE_PKG:
 126                 return PKGMGR_INSTALLER_UNINSTALL_EVENT_STR;
 127         case PKGMGR_REQ_UPGRADE:
 128                 return PKGMGR_INSTALLER_UPGRADE_EVENT_STR;
 129         case PKGMGR_REQ_MOVE:
 130                 return PKGMGR_INSTALLER_MOVE_EVENT_STR;
 131         case PKGMGR_REQ_ENABLE_APP:
 132                 return PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR;
 133         case PKGMGR_REQ_DISABLE_APP:
 134                 return PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR;
 135         case PKGMGR_REQ_ENABLE_APP_SPLASH_SCREEN:
 136                 return PKGMGR_INSTALLER_APP_ENABLE_SPLASH_SCREEN_EVENT_STR;
 137         case PKGMGR_REQ_DISABLE_APP_SPLASH_SCREEN:
 138                 return PKGMGR_INSTALLER_APP_DISABLE_SPLASH_SCREEN_EVENT_STR;
 139         case PKGMGR_REQ_CLEAR:
 140                 return PKGMGR_INSTALLER_CLEAR_EVENT_STR;
 141         case PKGMGR_REQ_GETSIZE:
 142                 return PKGMGR_INSTALLER_GET_SIZE_KEY_STR;
 143         }
 144
 145         ERR("cannot find type");
 146
 147         return NULL;
 148 }
 149
 150 static int __send_signal_for_event(pkgmgr_installer *pi, const char *pkg_type,
 151                 const char *pkgid, const char *appid, const char *key,
 152                 const char *val)
 153 {
 154         char *sid;
 155         const char *name;
 156         GError *err = NULL;
 157
 158         if (!pi || pi->conn == NULL)
 159                 return -1;
 160
 161         sid = pi->session_id;
 162         if (!sid)
 163                 sid = "";
 164
 165         name = __get_signal_name(pi, key);
 166         if (name == NULL) {
 167                 ERR("unknown signal type");
 168                 return -1;
 169         }
 170
 171         if (g_dbus_connection_emit_signal(pi->conn, NULL,
 172                                 PKGMGR_INSTALLER_DBUS_OBJECT_PATH,
 173                                 PKGMGR_INSTALLER_DBUS_INTERFACE, name,
 174                                 g_variant_new("(ussssss)", pi->target_uid, sid,
 175                                         pkg_type, pkgid, appid ? appid : "",
 176                                         key, val), &err)
 177                         != TRUE) {
 178                 ERR("failed to send dbus signal: %s", err->message);
 179                 g_error_free(err);
 180                 return -1;
 181         }
 182
 183         return 0;
 184 }
 185
 186 static int __send_signal_to_agent(uid_t uid, void *data, size_t len)
 187 {
 188         int fd;
 189         struct sockaddr_un sa;
 190         int r;
 191
 192         fd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0);
 193         if (fd == -1) {
 194                 ERR("failed to create socket: %d", errno);
 195                 return -1;
 196         }
 197
 198         sa.sun_family = AF_UNIX;
 199         snprintf(sa.sun_path, sizeof(sa.sun_path), "/run/pkgmgr/agent/%d", uid);
 200
 201         r = connect(fd, (struct sockaddr *)&sa, sizeof(sa));
 202         if (r == -1) {
 203                 ERR("failed to connect socket(%s): %d", sa.sun_path, errno);
 204                 close(fd);
 205                 return -1;
 206         }
 207
 208         r = send(fd, data, len, 0);
 209         if (r < 0) {
 210                 ERR("failed to send data: %d", errno);
 211                 close(fd);
 212                 return -1;
 213         }
 214
 215         close(fd);
 216
 217         return 0;
 218 }
 219
 220 static int __send_signal_for_event_for_uid(pkgmgr_installer *pi, uid_t uid,
 221                 const char *pkg_type, const char *pkgid, const char *appid,
 222                 const char *key, const char *val)
 223 {
 224         char *sid;
 225         const char *name;
 226         size_t name_size;
 227         GVariant *gv;
 228         gsize gv_len;
 229         gpointer gv_data;
 230         void *data;
 231         void *ptr;
 232         size_t data_len;
 233
 234         if (!pi || pi->conn == NULL)
 235                 return -1;
 236
 237         sid = pi->session_id;
 238         if (!sid)
 239                 sid = "";
 240
 241         data_len = sizeof(size_t) + sizeof(gsize);
 242
 243         name = __get_signal_name(pi, key);
 244         if (name == NULL) {
 245                 ERR("unknown signal type");
 246                 return -1;
 247         }
 248         /* including null byte */
 249         name_size = strlen(name) + 1;
 250         data_len += name_size;
 251
 252         gv = g_variant_new("(ussssss)", pi->target_uid, sid,
 253                         pkg_type, pkgid, appid ? appid : "", key, val);
 254         if (gv == NULL) {
 255                 ERR("failed to create GVariant instance");
 256                 return -1;
 257         }
 258         gv_len = g_variant_get_size(gv);
 259         gv_data = g_malloc(gv_len);
 260         g_variant_store(gv, gv_data);
 261         g_variant_unref(gv);
 262         data_len += gv_len;
 263
 264         data = malloc(data_len);
 265         ptr = data;
 266         memcpy(ptr, &name_size, sizeof(size_t));
 267         ptr += sizeof(size_t);
 268         memcpy(ptr, &gv_len, sizeof(gsize));
 269         ptr += sizeof(gsize);
 270         memcpy(ptr, name, name_size);
 271         ptr += name_size;
 272         memcpy(ptr, gv_data, gv_len);
 273         g_free(gv_data);
 274
 275         if (__send_signal_to_agent(uid, data, data_len)) {
 276                 ERR("failed to send signal to agent");
 277                 free(data);
 278                 return -1;
 279         }
 280
 281         free(data);
 282
 283         return 0;
 284 }
 285
 286 API pkgmgr_installer *pkgmgr_installer_new(void)
 287 {
 288         pkgmgr_installer *pi;
 289         GError *err = NULL;
 290
 291         pi = calloc(1, sizeof(struct pkgmgr_installer));
 292         if (pi == NULL)
 293                 return NULL;
 294
 295         pi->conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
 296         if (pi->conn == NULL) {
 297                 ERR("failed to get bus: %s", err->message);
 298                 g_error_free(err);
 299                 free(pi);
 300                 return NULL;
 301         }
 302
 303         pi->tep_path = NULL;
 304         pi->tep_move = 0;
 305         pi->request_type = PKGMGR_REQ_INVALID;
 306
 307         return pi;
 308 }
 309
 310 API pkgmgr_installer *pkgmgr_installer_offline_new(void)
 311 {
 312         pkgmgr_installer *pi;
 313
 314         pi = calloc(1, sizeof(struct pkgmgr_installer));
 315         if (pi == NULL)
 316                 return NULL;
 317
 318         pi->tep_path = NULL;
 319         pi->tep_move = 0;
 320         pi->request_type = PKGMGR_REQ_INVALID;
 321
 322         return pi;
 323 }
 324
 325 API int pkgmgr_installer_free(pkgmgr_installer *pi)
 326 {
 327         CHK_PI_RET(-EINVAL);
 328
 329         /* free members */
 330         if (pi->pkgmgr_info)
 331                 free(pi->pkgmgr_info);
 332         if (pi->session_id)
 333                 free(pi->session_id);
 334         if (pi->optional_data)
 335                 free(pi->optional_data);
 336         if (pi->caller_pkgid)
 337                 free(pi->caller_pkgid);
 338         if (pi->tep_path)
 339                 free(pi->tep_path);
 340
 341         if (pi->conn) {
 342                 g_dbus_connection_flush_sync(pi->conn, NULL, NULL);
 343                 g_object_unref(pi->conn);
 344         }
 345
 346         free(pi);
 347
 348         return 0;
 349 }
 350
 351 API int
 352 pkgmgr_installer_receive_request(pkgmgr_installer *pi,
 353                                  const int argc, char **argv)
 354 {
 355         CHK_PI_RET(-EINVAL);
 356
 357         int r = 0;
 358
 359         /* Parse argv */
 360         optind = 1;             /* Initialize optind to clear prev. index */
 361         int opt_idx = 0;
 362         int c;
 363         int mode = 0;
 364
 365         pi->target_uid = getuid();
 366         g_target_uid = pi->target_uid;
 367         while (1) {
 368                 c = getopt_long(argc, argv, short_opts, long_opts, &opt_idx);
 369                 /* printf("c=%d %c\n", c, c); //debug */
 370                 if (-1 == c)
 371                         break;  /* Parse is end */
 372                 switch (c) {
 373                 case OPTVAL_PRELOAD:    /* request for preload app */
 374                         pi->is_preload = 1;
 375                         DBG("preload request [%d]", pi->is_preload);
 376                         break;
 377                 case OPTVAL_FORCE_REMOVAL:      /* request for force-remove */
 378                         pi->force_removal = 1;
 379                         DBG("force-remove request [%d]", pi->force_removal);
 380                         break;
 381                 case OPTVAL_PRELOAD_RW: /* request for preload-rw app */
 382                         pi->is_preload_rw = 1;
 383                         DBG("preload-rw request [%d]", pi->is_preload_rw);
 384                         break;
 385                 case OPTVAL_NO_REMOVAL: /* request for no-remove */
 386                         pi->no_removal = 1;
 387                         DBG("no-remove request [%d]", pi->no_removal);
 388                         break;
 389                 case 'k':       /* session id */
 390                         if (pi->session_id)
 391                                 free(pi->session_id);
 392                         pi->session_id = strndup(optarg, MAX_STRLEN);
 393                         break;
 394
 395                 case 'l':       /* license path */
 396                         if (pi->license_path)
 397                                 free(pi->license_path);
 398                         pi->license_path = strndup(optarg, MAX_STRLEN);
 399                         break;
 400
 401                 case 'i':       /* install */
 402                         if (mode) {
 403                                 r = -EINVAL;
 404                                 goto RET;
 405                         }
 406                         mode = 'i';
 407                         pi->request_type = PKGMGR_REQ_INSTALL;
 408                         if (pi->pkgmgr_info)
 409                                 free(pi->pkgmgr_info);
 410                         pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
 411                         DBG("option is [i] pkgid[%s]", pi->pkgmgr_info);
 412                         if (pi->pkgmgr_info && strlen(pi->pkgmgr_info) == 0)
 413                                 free(pi->pkgmgr_info);
 414                         else
 415                                 mode = 'i';
 416                         break;
 417
 418                 case 'e':       /* install */
 419                         if (pi->tep_path)
 420                                 free(pi->tep_path);
 421                         pi->tep_path = strndup(optarg, MAX_STRLEN);
 422                         pi->is_tep_included = 1;
 423                         DBG("option is [e] tep_path[%s]", pi->tep_path);
 424                         break;
 425
 426                 case 'M':       /* install */
 427                         if (strcmp(optarg, "tep_move") == 0)
 428                                 pi->tep_move = 1;
 429                         else
 430                                 pi->tep_move = 0;
 431                         DBG("option is [M] tep_move[%d]", pi->tep_move);
 432                         break;
 433
 434                 case 'd':       /* uninstall */
 435                         if (mode) {
 436                                 r = -EINVAL;
 437                                 goto RET;
 438                         }
 439                         mode = 'd';
 440                         pi->request_type = PKGMGR_REQ_UNINSTALL;
 441                         if (pi->pkgmgr_info)
 442                                 free(pi->pkgmgr_info);
 443                         pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
 444                         break;
 445
 446
 447                 case 'c':       /* clear */
 448                         if (mode) {
 449                                 r = -EINVAL;
 450                                 goto RET;
 451                         }
 452                         mode = 'c';
 453                         pi->request_type = PKGMGR_REQ_CLEAR;
 454                         if (pi->pkgmgr_info)
 455                                 free(pi->pkgmgr_info);
 456                         pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
 457                         break;
 458
 459                 case 'm':       /* move */
 460                         if (mode) {
 461                                 r = -EINVAL;
 462                                 goto RET;
 463                         }
 464                         mode = 'm';
 465                         pi->request_type = PKGMGR_REQ_MOVE;
 466                         if (pi->pkgmgr_info)
 467                                 free(pi->pkgmgr_info);
 468                         pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
 469                         break;
 470
 471                 case 'r':       /* reinstall */
 472                         if (mode) {
 473                                 r = -EINVAL;
 474                                 goto RET;
 475                         }
 476                         mode = 'r';
 477                         pi->request_type = PKGMGR_REQ_REINSTALL;
 478                         if (pi->pkgmgr_info)
 479                                 free(pi->pkgmgr_info);
 480                         pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
 481                         break;
 482
 483                 case 't': /* move type*/
 484                         pi->move_type = atoi(optarg);
 485                         break;
 486
 487                 case 'p': /* caller pkgid*/
 488                         if (pi->caller_pkgid)
 489                                 free(pi->caller_pkgid);
 490                         pi->caller_pkgid = strndup(optarg, MAX_STRLEN);
 491
 492                         break;
 493
 494                 case 's':       /* smack */
 495                         if (mode) {
 496                                 r = -EINVAL;
 497                                 goto RET;
 498                         }
 499                         mode = 's';
 500                         pi->request_type = PKGMGR_REQ_SMACK;
 501                         if (pi->pkgmgr_info)
 502                                 free(pi->pkgmgr_info);
 503                         pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
 504                         break;
 505
 506                 case 'o': /* optional data*/
 507                         pi->optional_data = strndup(optarg, MAX_STRLEN);
 508                         break;
 509
 510                 case 'y': /* pkgid for direct manifest installation */
 511                         mode = 'y';
 512                         pi->request_type = PKGMGR_REQ_MANIFEST_DIRECT_INSTALL;
 513                         pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
 514                         break;
 515
 516                 case 'w': /* pkgid for mount installation */
 517                         mode = 'w';
 518                         pi->request_type = PKGMGR_REQ_MOUNT_INSTALL;
 519                         pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
 520                         break;
 521
 522                 case 'b': /* recovery */
 523                         if (mode) {
 524                                 r = -EINVAL;
 525                                 goto RET;
 526                         }
 527                         mode = 'b';
 528                         pi->request_type = PKGMGR_REQ_RECOVER;
 529                         if (pi->pkgmgr_info)
 530                                 free(pi->pkgmgr_info);
 531                         pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
 532                         break;
 533
 534                 case 'D': /* disable pkg */
 535                         pi->request_type = PKGMGR_REQ_DISABLE_PKG;
 536                         if (pi->pkgmgr_info)
 537                                 free(pi->pkgmgr_info);
 538                         pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
 539                         break;
 540
 541                 case 'A': /* enable pkg */
 542                         pi->request_type = PKGMGR_REQ_ENABLE_PKG;
 543                         if (pi->pkgmgr_info)
 544                                 free(pi->pkgmgr_info);
 545                         pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
 546                         break;
 547
 548                 case 'u': /* uid */
 549                         g_target_uid = (uid_t)atoi(optarg);
 550                         pi->target_uid = (uid_t)atoi(optarg);
 551                         break;
 552
 553                         /* Otherwise */
 554                 case '?':       /* Not an option */
 555                         break;
 556
 557                 case ':':       /* */
 558                         break;
 559
 560                 }
 561         }
 562
 563         /* if target user is not set, set as tizenglobalapp user */
 564         if (pi->target_uid == 0) {
 565                 pi->target_uid = tzplatform_getuid(TZ_SYS_GLOBALAPP_USER);
 566                 g_target_uid = pi->target_uid;
 567         }
 568  RET:
 569         return r;
 570 }
 571
 572 API int pkgmgr_installer_get_request_type(pkgmgr_installer *pi)
 573 {
 574         CHK_PI_RET(PKGMGR_REQ_INVALID);
 575         return pi->request_type;
 576 }
 577
 578 API uid_t pkgmgr_installer_get_uid(pkgmgr_installer *pi)
 579 {
 580         CHK_PI_RET(PKGMGR_REQ_INVALID);
 581         return pi->target_uid;
 582 }
 583
 584 API const char *pkgmgr_installer_get_request_info(pkgmgr_installer *pi)
 585 {
 586         CHK_PI_RET(PKGMGR_REQ_INVALID);
 587         return pi->pkgmgr_info;
 588 }
 589
 590 API const char *pkgmgr_installer_get_tep_path(pkgmgr_installer *pi)
 591 {
 592         CHK_PI_RET(PKGMGR_REQ_INVALID);
 593         return pi->tep_path;
 594 }
 595
 596 API int pkgmgr_installer_get_tep_move_type(pkgmgr_installer *pi)
 597 {
 598         CHK_PI_RET(PKGMGR_REQ_INVALID);
 599         return pi->tep_move;
 600 }
 601
 602 API const char *pkgmgr_installer_get_session_id(pkgmgr_installer *pi)
 603 {
 604         CHK_PI_RET(PKGMGR_REQ_INVALID);
 605         return pi->session_id;
 606 }
 607
 608 API const char *pkgmgr_installer_get_license_path(pkgmgr_installer *pi)
 609 {
 610         CHK_PI_RET(PKGMGR_REQ_INVALID);
 611         return pi->license_path;
 612 }
 613
 614 API const char *pkgmgr_installer_get_optional_data(pkgmgr_installer *pi)
 615 {
 616         CHK_PI_RET(PKGMGR_REQ_INVALID);
 617         return pi->optional_data;
 618 }
 619
 620 API int pkgmgr_installer_is_quiet(pkgmgr_installer *pi)
 621 {
 622         return 1;
 623 }
 624
 625 API int pkgmgr_installer_get_move_type(pkgmgr_installer *pi)
 626 {
 627         CHK_PI_RET(PKGMGR_REQ_INVALID);
 628         return pi->move_type;
 629 }
 630
 631 API const char *pkgmgr_installer_get_caller_pkgid(pkgmgr_installer *pi)
 632 {
 633         CHK_PI_RET(PKGMGR_REQ_INVALID);
 634         return pi->caller_pkgid;
 635 }
 636
 637 API int pkgmgr_installer_get_is_preload(pkgmgr_installer *pi)
 638 {
 639         CHK_PI_RET(PKGMGR_REQ_INVALID);
 640         return pi->is_preload;
 641 }
 642
 643 API int pkgmgr_installer_get_force_removal(pkgmgr_installer *pi)
 644 {
 645         CHK_PI_RET(PKGMGR_REQ_INVALID);
 646         return pi->force_removal;
 647 }
 648
 649 API int pkgmgr_installer_get_is_preload_rw(pkgmgr_installer *pi)
 650 {
 651         CHK_PI_RET(PKGMGR_REQ_INVALID);
 652         return pi->is_preload_rw;
 653 }
 654
 655 API int pkgmgr_installer_get_no_removal(pkgmgr_installer *pi)
 656 {
 657         CHK_PI_RET(PKGMGR_REQ_INVALID);
 658         return pi->no_removal;
 659 }
 660
 661 API int pkgmgr_installer_send_app_uninstall_signal(pkgmgr_installer *pi,
 662                              const char *pkg_type,
 663                              const char *pkgid,
 664                              const char *val)
 665 {
 666         int ret = 0;
 667         ret = __send_signal_for_event(pi, pkg_type, pkgid, NULL,
 668                         PKGMGR_INSTALLER_APPID_KEY_STR, val);
 669         return ret;
 670 }
 671
 672 API int pkgmgr_installer_send_app_uninstall_signal_for_uid(
 673                 pkgmgr_installer *pi, uid_t uid, const char *pkg_type,
 674                 const char *pkgid, const char *val)
 675 {
 676         int ret = 0;
 677         ret = __send_signal_for_event_for_uid(pi, uid, pkg_type, pkgid, NULL,
 678                         PKGMGR_INSTALLER_APPID_KEY_STR, val);
 679         return ret;
 680 }
 681
 682 API int pkgmgr_installer_set_uid(pkgmgr_installer *pi, uid_t uid)
 683 {
 684         if (pi == NULL)
 685                 return -1;
 686
 687         pi->target_uid = uid;
 688         g_target_uid = pi->target_uid;
 689
 690         return 0;
 691 }
 692
 693 API int
 694 pkgmgr_installer_send_app_signal(pkgmgr_installer *pi,
 695                              const char *pkg_type,
 696                              const char *pkgid,
 697                              const char *appid,
 698                              const char *key, const char *val)
 699 {
 700         int r = 0;
 701
 702         if (!pi->conn) {
 703                 ERR("connection is NULL");
 704                 return -1;
 705         }
 706
 707         r = __send_signal_for_event(pi, pkg_type, pkgid, appid, key, val);
 708
 709         return r;
 710 }
 711
 712 API int
 713 pkgmgr_installer_send_signal(pkgmgr_installer *pi,
 714                              const char *pkg_type,
 715                              const char *pkgid,
 716                              const char *key, const char *val)
 717 {
 718         int r = 0;
 719
 720         if (!pi->conn) {
 721                 ERR("connection is NULL");
 722                 return -1;
 723         }
 724
 725         if (strcmp(key, PKGMGR_INSTALLER_START_KEY_STR) == 0 &&
 726                         strcmp(val, PKGMGR_INSTALLER_UPGRADE_EVENT_STR) == 0)
 727                 pi->request_type = PKGMGR_REQ_UPGRADE;
 728
 729         r = __send_signal_for_event(pi, pkg_type, pkgid, NULL, key, val);
 730
 731         return r;
 732 }
 733
 734 API int pkgmgr_installer_send_app_signal_for_uid(pkgmgr_installer *pi,
 735                 uid_t uid, const char *pkg_type, const char *pkgid,
 736                 const char *appid, const char *key, const char *val)
 737 {
 738         int r = 0;
 739
 740         if (!pi->conn) {
 741                 ERR("connection is NULL");
 742                 return -1;
 743         }
 744
 745         r = __send_signal_for_event_for_uid(pi, uid, pkg_type, pkgid, appid,
 746                         key, val);
 747
 748         return r;
 749 }
 750
 751 API int pkgmgr_installer_send_signal_for_uid(pkgmgr_installer *pi,
 752                 uid_t uid, const char *pkg_type, const char *pkgid,
 753                 const char *key, const char *val)
 754 {
 755         int r = 0;
 756
 757         if (!pi->conn) {
 758                 ERR("connection is NULL");
 759                 return -1;
 760         }
 761
 762         if (strcmp(key, PKGMGR_INSTALLER_START_KEY_STR) == 0 &&
 763                         strcmp(val, PKGMGR_INSTALLER_UPGRADE_EVENT_STR) == 0)
 764                 pi->request_type = PKGMGR_REQ_UPGRADE;
 765
 766         r = __send_signal_for_event_for_uid(pi, uid, pkg_type, pkgid, NULL,
 767                         key, val);
 768
 769         return r;
 770 }
 771
 772 API int pkgmgr_installer_set_request_type(pkgmgr_installer *pi, int request_type)
 773 {
 774         if (pi == NULL)
 775                 return -1;
 776
 777         pi->request_type = request_type;
 778         return 0;
 779 }
 780
 781 API int pkgmgr_installer_set_session_id(pkgmgr_installer *pi, const char *session_id)
 782 {
 783         if (pi == NULL || session_id == NULL)
 784                 return -1;
 785
 786         pi->session_id = strndup(session_id, MAX_STRLEN);
 787         return 0;
 788 }
 789
 790 API int pkgmgr_installer_create_certinfo_set_handle(pkgmgr_instcertinfo_h *handle)
 791 {
 792         int ret = 0;
 793         ret = pkgmgrinfo_create_certinfo_set_handle(handle);
 794         return ret;
 795 }
 796
 797 API int pkgmgr_installer_set_cert_value(pkgmgr_instcertinfo_h handle, pkgmgr_instcert_type cert_type, char *cert_value)
 798 {
 799         int ret = 0;
 800         ret = pkgmgrinfo_set_cert_value(handle, cert_type, cert_value);
 801         return ret;
 802 }
 803
 804 API int pkgmgr_installer_save_certinfo(const char *pkgid, pkgmgr_instcertinfo_h handle, uid_t uid)
 805 {
 806         int ret = 0;
 807         ret = pkgmgrinfo_save_certinfo(pkgid, handle, uid);
 808         return ret;
 809 }
 810
 811 API int pkgmgr_installer_destroy_certinfo_set_handle(pkgmgr_instcertinfo_h handle)
 812 {
 813         int ret = 0;
 814         ret = pkgmgrinfo_destroy_certinfo_set_handle(handle);
 815         return ret;
 816 }
 817
 818 API int pkgmgr_installer_delete_certinfo(const char *pkgid)
 819 {
 820         int ret = 0;
 821         ret = pkgmgrinfo_delete_certinfo(pkgid);
 822         return ret;
 823 }
 824
 825 API int pkgmgr_installer_info_get_target_uid(uid_t *uid)
 826 {
 827         *uid = g_target_uid;
 828
 829         return 0;
 830 }