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