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