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