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