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