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