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