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