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