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