client/src/pkgmgr.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 <string.h>
  26 #include <unistd.h>
  27 #include <dlfcn.h>
  28 #include <dirent.h>
  29 #include <fcntl.h>
  30 #include <sys/wait.h>
  31 #include <sys/time.h>
  32 #include <unzip.h>
  33 #include <pthread.h>
  34
  35 #include <glib.h>
  36
  37 #include <pkgmgr-info.h>
  38 #include <iniparser.h>
  39 /* For multi-user support */
  40 #include <tzplatform_config.h>
  41
  42 #include "package-manager.h"
  43 #include "pkgmgr_client_debug.h"
  44 #include "pkgmgr_client_internal.h"
  45
  46 /* API export macro */
  47 #ifndef API
  48 #define API __attribute__ ((visibility("default")))
  49 #endif
  50
  51 #define BINSH_NAME      "/bin/sh"
  52 #define BINSH_SIZE      7
  53
  54 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
  55 #define REGULAR_USER 5000
  56
  57 static GList *jobs_to_free;
  58 static pthread_mutex_t __mutex = PTHREAD_MUTEX_INITIALIZER;
  59
  60 static inline uid_t _getuid(void)
  61 {
  62         uid_t uid = getuid();
  63
  64         if (uid < REGULAR_USER)
  65                 return GLOBAL_USER;
  66         else
  67                 return uid;
  68 }
  69
  70 static int _get_internal_request_id()
  71 {
  72         static int internal_req_id = 1;
  73
  74         return internal_req_id++;
  75 }
  76
  77 static char *_generate_request_id(void)
  78 {
  79         struct timeval tv;
  80         long curtime;
  81         char buf[BUFMAX];
  82
  83         gettimeofday(&tv, NULL);
  84         curtime = tv.tv_sec * 1000000 + tv.tv_usec;
  85
  86         snprintf(buf, sizeof(buf), "%d_%ld", getpid(), curtime);
  87
  88         return strdup(buf);
  89 }
  90
  91 static struct cb_info *__create_event_cb_info(struct pkgmgr_client_t *client,
  92                 pkgmgr_handler event_cb, void *data, const char *req_key)
  93 {
  94         struct cb_info *cb_info;
  95
  96         cb_info = calloc(1, sizeof(struct cb_info));
  97         if (cb_info == NULL) {
  98                 ERR("out of memory");
  99                 return NULL;
 100         }
 101         cb_info->client = client;
 102         cb_info->event_cb = event_cb;
 103         cb_info->data = data;
 104         cb_info->req_id = _get_internal_request_id();
 105         if (req_key != NULL) {
 106                 cb_info->req_key = strdup(req_key);
 107                 if (cb_info->req_key == NULL) {
 108                         ERR("out of memory");
 109                         free(cb_info);
 110                         return NULL;
 111                 }
 112         }
 113
 114         return cb_info;
 115 }
 116
 117 static struct cb_info *__create_app_event_cb_info(
 118                 struct pkgmgr_client_t *client, pkgmgr_app_handler app_event_cb,
 119                 void *data, const char *req_key)
 120 {
 121         struct cb_info *cb_info;
 122
 123         cb_info = calloc(1, sizeof(struct cb_info));
 124         if (cb_info == NULL) {
 125                 ERR("out of memory");
 126                 return NULL;
 127         }
 128         cb_info->client = client;
 129         cb_info->app_event_cb = app_event_cb;
 130         cb_info->data = data;
 131         cb_info->req_id = _get_internal_request_id();
 132         if (req_key != NULL) {
 133                 cb_info->req_key = strdup(req_key);
 134                 if (cb_info->req_key == NULL) {
 135                         ERR("out of memory");
 136                         free(cb_info);
 137                         return NULL;
 138                 }
 139         }
 140
 141         return cb_info;
 142 }
 143
 144 static struct cb_info *__create_size_info_cb_info(
 145                 struct pkgmgr_client_t *client,
 146                 pkgmgr_pkg_size_info_receive_cb size_info_cb,
 147                 void *data, const char *req_key)
 148 {
 149         struct cb_info *cb_info;
 150
 151         cb_info = calloc(1, sizeof(struct cb_info));
 152         if (cb_info == NULL) {
 153                 ERR("out of memory");
 154                 return NULL;
 155         }
 156         cb_info->client = client;
 157         cb_info->size_info_cb = size_info_cb;
 158         cb_info->data = data;
 159         cb_info->req_id = _get_internal_request_id();
 160         if (req_key != NULL) {
 161                 cb_info->req_key = strdup(req_key);
 162                 if (cb_info->req_key == NULL) {
 163                         ERR("out of memory");
 164                         free(cb_info);
 165                         return NULL;
 166                 }
 167         }
 168
 169         return cb_info;
 170 }
 171
 172 static int __jobs_to_free_add(gpointer data)
 173 {
 174         pthread_mutex_lock(&__mutex);
 175         if (g_list_find(jobs_to_free, data)) {
 176                 pthread_mutex_unlock(&__mutex);
 177                 return -1;
 178         }
 179
 180         jobs_to_free = g_list_append(jobs_to_free, data);
 181         pthread_mutex_unlock(&__mutex);
 182         return 0;
 183 }
 184
 185 static void __jobs_to_free_remove(gpointer data)
 186 {
 187         pthread_mutex_lock(&__mutex);
 188         jobs_to_free = g_list_remove(jobs_to_free, data);
 189         pthread_mutex_unlock(&__mutex);
 190 }
 191
 192 static void __do_free_cb_info(gpointer data)
 193 {
 194         struct cb_info *cb_info = (struct cb_info *)data;
 195
 196         g_list_free(cb_info->sid_list);
 197         free(cb_info->req_key);
 198         free(cb_info);
 199 }
 200
 201 static void __free_cb_info_cb(gpointer data)
 202 {
 203         g_idle_remove_by_data(data);
 204         __do_free_cb_info(data);
 205 }
 206
 207 __attribute__((destructor)) static void __free_cb_info_at_destructor(void)
 208 {
 209         pthread_mutex_lock(&__mutex);
 210         g_list_free_full(jobs_to_free, __free_cb_info_cb);
 211         pthread_mutex_unlock(&__mutex);
 212 }
 213
 214 static gboolean __free_cb_info_at_idle(gpointer data)
 215 {
 216         __jobs_to_free_remove(data);
 217         __do_free_cb_info(data);
 218
 219         return G_SOURCE_REMOVE;
 220 }
 221
 222 static void __free_cb_info(struct cb_info *cb_info)
 223 {
 224         if (__jobs_to_free_add(cb_info) < 0)
 225                 return;
 226
 227         g_idle_add(__free_cb_info_at_idle, cb_info);
 228 }
 229
 230 static int __get_size_process(pkgmgr_client *pc, const char *pkgid, uid_t uid,
 231                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
 232                 void *data)
 233 {
 234         GVariant *result;
 235         int ret = PKGMGR_R_ECOMM;
 236         long long size_info = 0;
 237         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 238
 239         if (pc == NULL || pkgid == NULL) {
 240                 ERR("invalid parameter");
 241                 return PKGMGR_R_EINVAL;
 242         }
 243
 244         if (client->pc_type != PC_REQUEST) {
 245                 ERR("client->pc_type is not PC_REQUEST");
 246                 return PKGMGR_R_EINVAL;
 247         }
 248
 249         ret = pkgmgr_client_connection_send_request(client, "getsize_sync",
 250                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
 251         if (ret != PKGMGR_R_OK) {
 252                 ERR("request failed: %d", ret);
 253                 return ret;
 254         }
 255
 256         g_variant_get(result, "(ix)", &ret, &size_info);
 257         if (ret != PKGMGR_R_OK) {
 258                 ERR("request result failed: %d", ret);
 259                 g_variant_unref(result);
 260                 return ret;
 261         }
 262
 263         if (size_info < 0) {
 264                 ERR("invalid size_info=(%lld)", size_info);
 265                 ret = -1;
 266         } else {
 267                 ret = (int)size_info;
 268                 DBG("size_info(%lld), return size(%d)", size_info, ret);
 269         }
 270
 271         g_variant_unref(result);
 272
 273         return ret;
 274 }
 275
 276 static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid,
 277                 const char *pkg_type, uid_t uid, pkgmgr_move_type move_type,
 278                 pkgmgr_handler event_cb, void *data)
 279 {
 280         int ret;
 281
 282         ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, event_cb, data, uid);
 283         if (ret < 0) {
 284                 ERR("move request failed");
 285                 return ret;
 286         }
 287
 288         return ret;
 289 }
 290
 291 static int __check_app_process(pkgmgr_request_service_type service_type,
 292                 pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data)
 293 {
 294         GVariant *result;
 295         int ret = PKGMGR_R_ECOMM;
 296         pkgmgrinfo_pkginfo_h handle;
 297         int pid = -1;
 298         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 299
 300         retvm_if(client->pc_type != PC_REQUEST, PKGMGR_R_EINVAL, "client->pc_type is not PC_REQUEST\n");
 301
 302         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
 303         if (ret != PMINFO_R_OK) {
 304                 ERR("pkgmgrinfo_pkginfo_get_pkginfo failed");
 305                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 306                 return PKGMGR_R_ERROR;
 307         }
 308
 309         if (service_type == PM_REQUEST_KILL_APP) {
 310                 ret = pkgmgr_client_connection_send_request(client, "kill",
 311                                 g_variant_new("(us)", uid, pkgid), &result);
 312         } else if (service_type == PM_REQUEST_CHECK_APP) {
 313                 ret = pkgmgr_client_connection_send_request(client, "check",
 314                                 g_variant_new("(us)", uid, pkgid), &result);
 315         } else {
 316                 ERR("unexpected service type: %d", service_type);
 317                 ret = PKGMGR_R_ERROR;
 318         }
 319
 320         if (ret != PKGMGR_R_OK) {
 321                 ERR("request failed: %d", ret);
 322                 return ret;
 323         }
 324
 325         g_variant_get(result, "(ii)", &ret, &pid);
 326         g_variant_unref(result);
 327         if (ret != PKGMGR_R_OK) {
 328                 ERR("request failed, ret=%d", ret);
 329                 return ret;
 330         }
 331
 332         *(int *)data = pid;
 333
 334         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 335
 336         return ret;
 337
 338 }
 339
 340 API pkgmgr_client *pkgmgr_client_new(pkgmgr_client_type pc_type)
 341 {
 342         struct pkgmgr_client_t *client;
 343
 344         if (pc_type == PC_BROADCAST) {
 345                 ERR("broadcast type is not supported");
 346                 return NULL;
 347         }
 348
 349         if (pc_type != PC_REQUEST && pc_type != PC_LISTENING) {
 350                 ERR("invalid parameter");
 351                 return NULL;
 352         }
 353
 354         client = calloc(1, sizeof(struct pkgmgr_client_t));
 355         if (client == NULL) {
 356                 ERR("out of memory");
 357                 return NULL;
 358         }
 359
 360         client->pc_type = pc_type;
 361         client->status_type = PKGMGR_CLIENT_STATUS_ALL;
 362
 363         if (pkgmgr_client_connection_connect(client) != PKGMGR_R_OK) {
 364                 free(client);
 365                 return NULL;
 366         }
 367
 368         return (pkgmgr_client *)client;
 369 }
 370
 371 API int pkgmgr_client_free(pkgmgr_client *pc)
 372 {
 373         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 374
 375         if (pc == NULL) {
 376                 ERR("invalid argument");
 377                 return PKGMGR_R_EINVAL;
 378         }
 379
 380         pkgmgr_client_remove_listen_status(client);
 381         pkgmgr_client_connection_disconnect(client);
 382         if (client->tep_path)
 383                 free(client->tep_path);
 384         free(client);
 385
 386         return PKGMGR_R_OK;
 387 }
 388
 389 struct manifest_and_type type_map[] = {
 390                 { "res/wgt/config.xml", "wgt" },
 391                 { "config.xml", "wgt" },
 392                 { "tizen-manifest.xml", "tpk" },
 393                 { NULL, NULL }
 394 };
 395
 396 static char *__get_type_from_path(const char *pkg_path)
 397 {
 398         const char *type = NULL;
 399         unzFile uf;
 400         int i;
 401
 402         uf = unzOpen(pkg_path);
 403         if (uf == NULL) {
 404                 ERR("failed to open zip file %s", pkg_path);
 405                 return NULL;
 406         }
 407
 408         for (i = 0; type_map[i].manifest != NULL; i++) {
 409                 if (unzLocateFile(uf, type_map[i].manifest, 0) == UNZ_OK) {
 410                         DBG("pkgtype of %s: [%s]", pkg_path, type_map[i].type);
 411                         type = type_map[i].type;
 412                         break;
 413                 }
 414         }
 415         unzClose(uf);
 416
 417         return type ? strdup(type) : NULL;
 418 }
 419
 420 API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, const char *tep_path,
 421                 bool tep_move)
 422 {
 423         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *) pc;
 424
 425         if (pc == NULL || tep_path == NULL) {
 426                 ERR("invalied parameter");
 427                 return PKGMGR_R_EINVAL;
 428         }
 429
 430         if (client->tep_path)
 431                 free(client->tep_path);
 432
 433         client->tep_path = strdup(tep_path);
 434         client->tep_move = tep_move;
 435
 436         return PKGMGR_R_OK;
 437 }
 438
 439 API int pkgmgr_client_usr_install_packages(pkgmgr_client *pc,
 440                 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
 441                 void *data, uid_t uid)
 442 {
 443         GVariant *result;
 444         GVariantBuilder *pkgs_builder;
 445         GVariant *pkgs;
 446         GVariantBuilder *args_builder;
 447         GVariant *args;
 448         int ret;
 449         char *req_key = NULL;
 450         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 451         struct cb_info *cb_info;
 452         int i;
 453         char *request_id = NULL;
 454
 455         if (pc == NULL || pkg_paths == NULL || n_pkgs < 1) {
 456                 ERR("invalid parameter");
 457                 return PKGMGR_R_EINVAL;
 458         }
 459
 460         if (client->pc_type != PC_REQUEST) {
 461                 ERR("client type is not PC_REQUEST");
 462                 return PKGMGR_R_EINVAL;
 463         }
 464
 465         for (i = 0; i < n_pkgs; i++) {
 466                 if (access(pkg_paths[i], F_OK) != 0) {
 467                         ERR("failed to access: %s", pkg_paths[i]);
 468                         return PKGMGR_R_EINVAL;
 469                 }
 470         }
 471
 472         pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 473         for (i = 0; i < n_pkgs; i++)
 474                 g_variant_builder_add(pkgs_builder, "s", pkg_paths[i]);
 475         pkgs = g_variant_new("as", pkgs_builder);
 476         g_variant_builder_unref(pkgs_builder);
 477
 478         args_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 479         if (client->debug_mode)
 480                 g_variant_builder_add(args_builder, "s", "-G");
 481         if (client->skip_optimization)
 482                 g_variant_builder_add(args_builder, "s", "-S");
 483         args = g_variant_new("as", args_builder);
 484         g_variant_builder_unref(args_builder);
 485
 486         request_id = _generate_request_id();
 487         ret = pkgmgr_client_connection_send_request(client, "install_pkgs",
 488                         g_variant_new("(u@as@ass)", uid, pkgs, args,
 489                                         request_id),
 490                         &result);
 491         free(request_id);
 492         if (ret != PKGMGR_R_OK) {
 493                 ERR("request failed: %d", ret);
 494                 return ret;
 495         }
 496
 497         g_variant_get(result, "(i&s)", &ret, &req_key);
 498         if (req_key == NULL) {
 499                 g_variant_unref(result);
 500                 return PKGMGR_R_ECOMM;
 501         }
 502         if (ret != PKGMGR_R_OK) {
 503                 g_variant_unref(result);
 504                 return ret;
 505         }
 506
 507         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
 508         if (cb_info == NULL) {
 509                 g_variant_unref(result);
 510                 return PKGMGR_R_ERROR;
 511         }
 512         g_variant_unref(result);
 513         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 514         if (ret != PKGMGR_R_OK) {
 515                 __free_cb_info(cb_info);
 516                 return ret;
 517         }
 518         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 519
 520         return cb_info->req_id;
 521 }
 522
 523 API int pkgmgr_client_install_packages(pkgmgr_client *pc,
 524                 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
 525                 void *data)
 526 {
 527         return pkgmgr_client_usr_install_packages(pc, pkg_paths, n_pkgs,
 528                         event_cb, data, _getuid());
 529 }
 530
 531 API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
 532                 const char *descriptor_path, const char *pkg_path,
 533                 const char *optional_data, pkgmgr_mode mode,
 534                 pkgmgr_handler event_cb, void *data, uid_t uid)
 535 {
 536         GVariant *result;
 537         int ret = PKGMGR_R_ECOMM;
 538         char *req_key = NULL;
 539         GVariantBuilder *builder = NULL;
 540         GVariant *args = NULL;
 541         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 542         struct cb_info *cb_info;
 543         char *request_id = NULL;
 544
 545         if (pc == NULL || pkg_path == NULL) {
 546                 ERR("invalid parameter");
 547                 return PKGMGR_R_EINVAL;
 548         }
 549
 550         if (client->pc_type != PC_REQUEST) {
 551                 ERR("client type is not PC_REQUEST");
 552                 return PKGMGR_R_EINVAL;
 553         }
 554
 555         if (access(pkg_path, F_OK) != 0) {
 556                 ERR("failed to access: %s", pkg_path);
 557                 return PKGMGR_R_EINVAL;
 558         }
 559
 560         if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
 561                 ERR("failed to access: %s", client->tep_path);
 562                 return PKGMGR_R_EINVAL;
 563         }
 564
 565         /* build arguments */
 566         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 567         if (client->tep_path) {
 568                 g_variant_builder_add(builder, "s", "-e");
 569                 g_variant_builder_add(builder, "s", client->tep_path);
 570                 g_variant_builder_add(builder, "s", "-M");
 571                 /* TODO: revise tep_move */
 572                 g_variant_builder_add(builder, "s",
 573                                 client->tep_move ? "tep_move" : "tep_copy");
 574         }
 575         if (client->debug_mode)
 576                 g_variant_builder_add(builder, "s", "-G");
 577         if (client->skip_optimization)
 578                 g_variant_builder_add(builder, "s", "-S");
 579
 580         args = g_variant_new("as", builder);
 581         g_variant_builder_unref(builder);
 582
 583         request_id = _generate_request_id();
 584         ret = pkgmgr_client_connection_send_request(client, "install",
 585                         g_variant_new("(uss@ass)", uid, pkg_type ? pkg_type : "",
 586                                 pkg_path, args, request_id),
 587                         &result);
 588         free(request_id);
 589         if (ret != PKGMGR_R_OK) {
 590                 ERR("request failed: %d", ret);
 591                 return ret;
 592         }
 593
 594         g_variant_get(result, "(i&s)", &ret, &req_key);
 595         if (req_key == NULL) {
 596                 g_variant_unref(result);
 597                 return PKGMGR_R_ECOMM;
 598         }
 599         if (ret != PKGMGR_R_OK) {
 600                 g_variant_unref(result);
 601                 return ret;
 602         }
 603
 604         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
 605         if (cb_info == NULL) {
 606                 g_variant_unref(result);
 607                 return PKGMGR_R_ENOMEM;
 608         }
 609         g_variant_unref(result);
 610         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 611         if (ret != PKGMGR_R_OK) {
 612                 __free_cb_info(cb_info);
 613                 return ret;
 614         }
 615         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 616         return cb_info->req_id;
 617 }
 618
 619 API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
 620                 const char *descriptor_path, const char *pkg_path,
 621                 const char *optional_data, pkgmgr_mode mode,
 622                 pkgmgr_handler event_cb, void *data)
 623 {
 624         return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path,
 625                         pkg_path, optional_data, mode, event_cb, data,
 626                         _getuid());
 627 }
 628
 629 API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
 630                 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
 631                 pkgmgr_handler event_cb, void *data)
 632 {
 633         return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_data,
 634                         mode, event_cb, data, _getuid());
 635 }
 636
 637 API int pkgmgr_client_usr_reinstall(pkgmgr_client *pc, const char *pkg_type,
 638                 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
 639                 pkgmgr_handler event_cb, void *data, uid_t uid)
 640 {
 641         GVariant *result;
 642         int ret = PKGMGR_R_ECOMM;
 643         char *req_key = NULL;
 644         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 645         struct cb_info *cb_info;
 646
 647         if (pc == NULL || pkgid == NULL) {
 648                 ERR("invalid parameter");
 649                 return PKGMGR_R_EINVAL;
 650         }
 651
 652         if (client->pc_type != PC_REQUEST) {
 653                 ERR("client->pc_type is not PC_REQUEST");
 654                 return PKGMGR_R_EINVAL;
 655         }
 656
 657         ret = pkgmgr_client_connection_send_request(client, "reinstall",
 658                         g_variant_new("(us)", uid, pkgid), &result);
 659         if (ret != PKGMGR_R_OK) {
 660                 ERR("request failed: %d", ret);
 661                 return ret;
 662         }
 663
 664         g_variant_get(result, "(i&s)", &ret, &req_key);
 665         if (req_key == NULL) {
 666                 g_variant_unref(result);
 667                 return PKGMGR_R_ECOMM;
 668         }
 669         if (ret != PKGMGR_R_OK) {
 670                 g_variant_unref(result);
 671                 return ret;
 672         }
 673
 674         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
 675         if (cb_info == NULL) {
 676                 g_variant_unref(result);
 677                 return PKGMGR_R_ENOMEM;
 678         }
 679         g_variant_unref(result);
 680         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 681         if (ret != PKGMGR_R_OK) {
 682                 __free_cb_info(cb_info);
 683                 return ret;
 684         }
 685         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 686
 687         return cb_info->req_id;
 688 }
 689
 690 API int pkgmgr_client_usr_mount_install_packages(pkgmgr_client *pc,
 691                 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
 692                 void *data, uid_t uid)
 693 {
 694         GVariant *result;
 695         GVariantBuilder *pkgs_builder;
 696         GVariant *pkgs;
 697         int ret = PKGMGR_R_ECOMM;
 698         char *req_key = NULL;
 699         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 700         struct cb_info *cb_info;
 701         int i;
 702         char *request_id = NULL;
 703
 704         if (pc == NULL || pkg_paths == NULL || n_pkgs < 1) {
 705                 ERR("invalid parameter");
 706                 return PKGMGR_R_EINVAL;
 707         }
 708
 709         if (client->pc_type != PC_REQUEST) {
 710                 ERR("client->pc_type is not PC_REQUEST");
 711                 return PKGMGR_R_EINVAL;
 712         }
 713
 714         for (i = 0; i < n_pkgs; i++) {
 715                 if (access(pkg_paths[i], F_OK) != 0) {
 716                         ERR("failed to access: %s", pkg_paths[i]);
 717                         return PKGMGR_R_EINVAL;
 718                 }
 719         }
 720
 721         pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 722         for (i = 0; i < n_pkgs; i++)
 723                 g_variant_builder_add(pkgs_builder, "s", pkg_paths[i]);
 724         pkgs = g_variant_new("as", pkgs_builder);
 725         g_variant_builder_unref(pkgs_builder);
 726
 727         request_id = _generate_request_id();
 728         ret = pkgmgr_client_connection_send_request(client,
 729                         "mount_install_pkgs",
 730                         g_variant_new("(u@ass)", uid, pkgs, request_id),
 731                         &result);
 732         free(request_id);
 733         if (ret != PKGMGR_R_OK) {
 734                 ERR("request failed: %d", ret);
 735                 return ret;
 736         }
 737
 738         g_variant_get(result, "(i&s)", &ret, &req_key);
 739         if (req_key == NULL) {
 740                 g_variant_unref(result);
 741                 return PKGMGR_R_ECOMM;
 742         }
 743         if (ret != PKGMGR_R_OK) {
 744                 g_variant_unref(result);
 745                 return ret;
 746         }
 747
 748         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
 749         if (cb_info == NULL) {
 750                 g_variant_unref(result);
 751                 return PKGMGR_R_ENOMEM;
 752         }
 753         g_variant_unref(result);
 754         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 755         if (ret != PKGMGR_R_OK) {
 756                 __free_cb_info(cb_info);
 757                 return ret;
 758         }
 759         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 760
 761         return cb_info->req_id;
 762 }
 763
 764 API int pkgmgr_client_mount_install_packages(pkgmgr_client *pc,
 765                 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
 766                 void *data)
 767 {
 768         return pkgmgr_client_usr_mount_install_packages(pc, pkg_paths, n_pkgs,
 769                         event_cb, data, _getuid());
 770 }
 771
 772 API int pkgmgr_client_usr_mount_install(pkgmgr_client *pc, const char *pkg_type,
 773                 const char *descriptor_path, const char *pkg_path,
 774                 const char *optional_data, pkgmgr_mode mode,
 775                 pkgmgr_handler event_cb, void *data, uid_t uid)
 776 {
 777         GVariant *result;
 778         int ret = PKGMGR_R_ECOMM;
 779         char *req_key = NULL;
 780         GVariantBuilder *builder = NULL;
 781         GVariant *args = NULL;
 782         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 783         struct cb_info *cb_info;
 784         char *request_id = NULL;
 785
 786         if (pc == NULL || pkg_path == NULL) {
 787                 ERR("invalid parameter");
 788                 return PKGMGR_R_EINVAL;
 789         }
 790
 791         if (client->pc_type != PC_REQUEST) {
 792                 ERR("client->pc_type is not PC_REQUEST");
 793                 return PKGMGR_R_EINVAL;
 794         }
 795
 796         if (access(pkg_path, F_OK) != 0) {
 797                 ERR("failed to access: %s", pkg_path);
 798                 return PKGMGR_R_EINVAL;
 799         }
 800
 801         if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
 802                 ERR("failed to access: %s", client->tep_path);
 803                 return PKGMGR_R_EINVAL;
 804         }
 805
 806         /* build arguments */
 807         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 808         if (client->tep_path) {
 809                 g_variant_builder_add(builder, "s", "-e");
 810                 g_variant_builder_add(builder, "s", client->tep_path);
 811                 g_variant_builder_add(builder, "s", "-M");
 812                 /* TODO: revise tep_move */
 813                 g_variant_builder_add(builder, "s",
 814                                 client->tep_move ? "tep_move" : "tep_copy");
 815         }
 816
 817         args = g_variant_new("as", builder);
 818         g_variant_builder_unref(builder);
 819
 820         request_id = _generate_request_id();
 821         ret = pkgmgr_client_connection_send_request(client, "mount_install",
 822                         g_variant_new("(uss@ass)", uid,
 823                                         pkg_type ? pkg_type : "", pkg_path,
 824                                         args, request_id),
 825                         &result);
 826         free(request_id);
 827         if (ret != PKGMGR_R_OK) {
 828                 ERR("request failed: %d", ret);
 829                 return ret;
 830         }
 831
 832         g_variant_get(result, "(i&s)", &ret, &req_key);
 833         if (req_key == NULL) {
 834                 g_variant_unref(result);
 835                 return PKGMGR_R_ECOMM;
 836         }
 837         if (ret != PKGMGR_R_OK) {
 838                 g_variant_unref(result);
 839                 return ret;
 840         }
 841
 842         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
 843         if (cb_info == NULL) {
 844                 g_variant_unref(result);
 845                 return PKGMGR_R_ENOMEM;
 846         }
 847         g_variant_unref(result);
 848         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 849         if (ret != PKGMGR_R_OK) {
 850                 __free_cb_info(cb_info);
 851                 return ret;
 852         }
 853         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 854
 855         return cb_info->req_id;
 856 }
 857
 858 API int pkgmgr_client_mount_install(pkgmgr_client *pc, const char *pkg_type,
 859                 const char *descriptor_path, const char *pkg_path,
 860                 const char *optional_data, pkgmgr_mode mode,
 861                 pkgmgr_handler event_cb, void *data)
 862 {
 863         return pkgmgr_client_usr_mount_install(pc, pkg_type, descriptor_path,
 864                         pkg_path, optional_data, mode, event_cb, data,
 865                         _getuid());
 866 }
 867
 868 API int pkgmgr_client_usr_uninstall_packages(pkgmgr_client *pc,
 869                 const char **pkgids, int n_pkgs, pkgmgr_handler event_cb,
 870                 void *data, uid_t uid)
 871 {
 872         GVariant *result;
 873         GVariantBuilder *pkgs_builder;
 874         GVariant *pkgs;
 875         int ret = PKGMGR_R_ECOMM;
 876         char *req_key = NULL;
 877         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 878         struct cb_info *cb_info;
 879         int i;
 880
 881         if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
 882                 ERR("invalid parameter");
 883                 return PKGMGR_R_EINVAL;
 884         }
 885
 886         if (client->pc_type != PC_REQUEST) {
 887                 ERR("client->pc_type is not PC_REQUEST");
 888                 return PKGMGR_R_EINVAL;
 889         }
 890
 891         pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 892         for (i = 0; i < n_pkgs; i++)
 893                 g_variant_builder_add(pkgs_builder, "s", pkgids[i]);
 894         pkgs = g_variant_new("as", pkgs_builder);
 895         g_variant_builder_unref(pkgs_builder);
 896
 897         ret = pkgmgr_client_connection_send_request(client, "uninstall_pkgs",
 898                         g_variant_new("(u@as)", uid, pkgs), &result);
 899         if (ret != PKGMGR_R_OK) {
 900                 ERR("request failed: %d", ret);
 901                 return ret;
 902         }
 903
 904         g_variant_get(result, "(i&s)", &ret, &req_key);
 905         if (req_key == NULL) {
 906                 g_variant_unref(result);
 907                 return PKGMGR_R_ECOMM;
 908         }
 909         if (ret != PKGMGR_R_OK) {
 910                 g_variant_unref(result);
 911                 return ret;
 912         }
 913
 914         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
 915         if (cb_info == NULL) {
 916                 g_variant_unref(result);
 917                 return PKGMGR_R_ENOMEM;
 918         }
 919         g_variant_unref(result);
 920         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 921         if (ret != PKGMGR_R_OK) {
 922                 __free_cb_info(cb_info);
 923                 return ret;
 924         }
 925         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 926
 927         return cb_info->req_id;
 928 }
 929
 930 API int pkgmgr_client_uninstall_packages(pkgmgr_client *pc,
 931                 const char **pkgids, int n_pkgs, pkgmgr_handler event_cb,
 932                 void *data)
 933 {
 934         return pkgmgr_client_usr_uninstall_packages(pc, pkgids, n_pkgs,
 935                         event_cb, data, _getuid());
 936 }
 937
 938 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
 939                 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
 940                 void *data)
 941 {
 942         return pkgmgr_client_usr_uninstall(pc, pkg_type, pkgid, mode, event_cb,
 943                         data, _getuid());
 944 }
 945
 946 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
 947                 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
 948                 void *data, uid_t uid)
 949 {
 950         GVariant *result;
 951         int ret = PKGMGR_R_ECOMM;
 952         char *req_key = NULL;
 953         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 954         struct cb_info *cb_info;
 955
 956         if (pc == NULL || pkgid == NULL) {
 957                 ERR("invalid parameter");
 958                 return PKGMGR_R_EINVAL;
 959         }
 960
 961         if (client->pc_type != PC_REQUEST) {
 962                 ERR("client->pc_type is not PC_REQUEST");
 963                 return PKGMGR_R_EINVAL;
 964         }
 965
 966         ret = pkgmgr_client_connection_send_request(client, "uninstall",
 967                         g_variant_new("(us)", uid, pkgid), &result);
 968         if (ret != PKGMGR_R_OK) {
 969                 ERR("request failed: %d", ret);
 970                 return ret;
 971         }
 972
 973         g_variant_get(result, "(i&s)", &ret, &req_key);
 974         if (req_key == NULL) {
 975                 g_variant_unref(result);
 976                 return PKGMGR_R_ECOMM;
 977         }
 978         if (ret != PKGMGR_R_OK) {
 979                 g_variant_unref(result);
 980                 return ret;
 981         }
 982
 983         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
 984         if (cb_info == NULL) {
 985                 g_variant_unref(result);
 986                 return PKGMGR_R_ENOMEM;
 987         }
 988         g_variant_unref(result);
 989         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 990         if (ret != PKGMGR_R_OK) {
 991                 __free_cb_info(cb_info);
 992                 return ret;
 993         }
 994         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 995
 996         return cb_info->req_id;
 997 }
 998
 999 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
1000                 const char *pkgid, pkgmgr_move_type move_type,
1001                 pkgmgr_handler event_cb, void *data)
1002 {
1003         return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type,
1004                         event_cb, data, _getuid());
1005 }
1006 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
1007                 const char *pkgid, pkgmgr_move_type move_type,
1008                 pkgmgr_handler event_cb, void *data, uid_t uid)
1009 {
1010         GVariant *result;
1011         int ret = PKGMGR_R_ECOMM;
1012         char *req_key = NULL;
1013         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1014         struct cb_info *cb_info;
1015
1016         if (pc == NULL || pkgid == NULL) {
1017                 ERR("invalid parameter");
1018                 return PKGMGR_R_EINVAL;
1019         }
1020
1021         if ((move_type < PM_MOVE_TO_INTERNAL) ||
1022                         (move_type > PM_MOVE_TO_EXTENDED))
1023                 return PKGMGR_R_EINVAL;
1024
1025         if (client->pc_type != PC_REQUEST) {
1026                 ERR("client->pc_type is not PC_REQUEST");
1027                 return PKGMGR_R_EINVAL;
1028         }
1029
1030         ret = pkgmgr_client_connection_send_request(client, "move",
1031                         g_variant_new("(usi)", uid, pkgid, move_type), &result);
1032         if (ret != PKGMGR_R_OK) {
1033                 ERR("request failed: %d", ret);
1034                 return ret;
1035         }
1036
1037         g_variant_get(result, "(i&s)", &ret, &req_key);
1038         if (req_key == NULL) {
1039                 g_variant_unref(result);
1040                 return PKGMGR_R_ECOMM;
1041         }
1042         if (ret != PKGMGR_R_OK) {
1043                 g_variant_unref(result);
1044                 return ret;
1045         }
1046
1047         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1048         if (cb_info == NULL) {
1049                 g_variant_unref(result);
1050                 return PKGMGR_R_ERROR;
1051         }
1052         g_variant_unref(result);
1053         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1054         if (ret != PKGMGR_R_OK) {
1055                 __free_cb_info(cb_info);
1056                 return ret;
1057         }
1058         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1059
1060         return cb_info->req_id;
1061 }
1062
1063 API int pkgmgr_client_usr_register_pkg_update_info(pkgmgr_client *pc,
1064                 pkg_update_info_t *update_info, uid_t uid)
1065 {
1066         int ret;
1067         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1068         GVariant *result;
1069
1070         if (pc == NULL || update_info == NULL || update_info->pkgid == NULL) {
1071                 ERR("invalid parameter");
1072                 return PKGMGR_R_EINVAL;
1073         }
1074
1075         if (client->pc_type != PC_REQUEST) {
1076                 ERR("client->pc_type is not PC_REQUEST");
1077                 return PKGMGR_R_EINVAL;
1078         }
1079
1080         ret = pkgmgr_client_connection_send_request(client, "register_pkg_update_info",
1081                         g_variant_new("(ussi)", uid, update_info->pkgid, update_info->version,
1082                         update_info->type), &result);
1083         if (ret != PKGMGR_R_OK) {
1084                 ERR("request failed: %d", ret);
1085                 return ret;
1086         }
1087
1088         g_variant_get(result, "(i)", &ret);
1089         if (ret != PKGMGR_R_OK) {
1090                 g_variant_unref(result);
1091                 return ret;
1092         }
1093         g_variant_unref(result);
1094
1095         return PKGMGR_R_OK;
1096 }
1097
1098 API int pkgmgr_client_register_pkg_update_info(pkgmgr_client *pc,
1099                 pkg_update_info_t *update_info)
1100 {
1101         return pkgmgr_client_usr_register_pkg_update_info(pc, update_info,
1102                         _getuid());
1103 }
1104
1105 API int pkgmgr_client_usr_unregister_pkg_update_info(pkgmgr_client *pc,
1106                 const char *pkgid, uid_t uid)
1107 {
1108         int ret;
1109         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1110         GVariant *result;
1111
1112         if (pc == NULL || pkgid == NULL) {
1113                 ERR("invalid parameter");
1114                 return PKGMGR_R_EINVAL;
1115         }
1116
1117         if (client->pc_type != PC_REQUEST) {
1118                 ERR("client->pc_type is not PC_REQUEST");
1119                 return PKGMGR_R_EINVAL;
1120         }
1121
1122         ret = pkgmgr_client_connection_send_request(client,
1123                         "unregister_pkg_update_info",
1124                         g_variant_new("(us)", uid, pkgid), &result);
1125         if (ret != PKGMGR_R_OK) {
1126                 ERR("request failed: %d", ret);
1127                 return ret;
1128         }
1129
1130         g_variant_get(result, "(i)", &ret);
1131         if (ret != PKGMGR_R_OK) {
1132                 g_variant_unref(result);
1133                 return ret;
1134         }
1135         g_variant_unref(result);
1136
1137         return PKGMGR_R_OK;
1138 }
1139
1140 API int pkgmgr_client_unregister_pkg_update_info(pkgmgr_client *pc,
1141                 const char *pkgid)
1142 {
1143         return pkgmgr_client_usr_unregister_pkg_update_info(pc, pkgid, _getuid());
1144 }
1145
1146 API int pkgmgr_client_usr_unregister_all_pkg_update_info(pkgmgr_client *pc,
1147                 uid_t uid)
1148 {
1149         int ret;
1150         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1151         GVariant *result;
1152
1153         if (pc == NULL) {
1154                 ERR("invalid parameter");
1155                 return PKGMGR_R_EINVAL;
1156         }
1157
1158         if (client->pc_type != PC_REQUEST) {
1159                 ERR("client->pc_type is not PC_REQUEST");
1160                 return PKGMGR_R_EINVAL;
1161         }
1162
1163         ret = pkgmgr_client_connection_send_request(client,
1164                         "unregister_all_pkg_update_info",
1165                         g_variant_new("(u)", uid), &result);
1166         if (ret != PKGMGR_R_OK) {
1167                 ERR("request failed: %d", ret);
1168                 return ret;
1169         }
1170
1171         g_variant_get(result, "(i)", &ret);
1172         if (ret != PKGMGR_R_OK) {
1173                 g_variant_unref(result);
1174                 return ret;
1175         }
1176         g_variant_unref(result);
1177
1178         return PKGMGR_R_OK;
1179 }
1180
1181 API int pkgmgr_client_unregister_all_pkg_update_info(pkgmgr_client *pc)
1182 {
1183         return pkgmgr_client_usr_unregister_all_pkg_update_info(pc, _getuid());
1184 }
1185
1186 API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
1187                 const char *pkgid, uid_t uid)
1188 {
1189         GVariant *result;
1190         int ret = PKGMGR_R_ECOMM;
1191         GVariantBuilder *builder;
1192         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1193
1194         if (pc == NULL || pkgid == NULL) {
1195                 ERR("invalid parameter");
1196                 return PKGMGR_R_EINVAL;
1197         }
1198
1199         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1200         g_variant_builder_add(builder, "s", pkgid);
1201
1202         ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
1203                         g_variant_new("(uas)", uid, builder), &result);
1204         g_variant_builder_unref(builder);
1205         if (ret != PKGMGR_R_OK) {
1206                 ERR("request failed: %d", ret);
1207                 return ret;
1208         }
1209
1210         g_variant_get(result, "(is)", &ret, NULL);
1211         g_variant_unref(result);
1212
1213         return ret;
1214 }
1215
1216 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
1217                 const char *pkgid)
1218 {
1219         return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, _getuid());
1220 }
1221
1222 API int pkgmgr_client_usr_activate_packages(pkgmgr_client *pc,
1223                 const char *pkg_type, const char **pkgids, int n_pkgs,
1224                 pkgmgr_handler event_cb, void *data, uid_t uid)
1225 {
1226         GVariant *result;
1227         GVariantBuilder *builder;
1228         int ret = PKGMGR_R_ECOMM;
1229         char *req_key = NULL;
1230         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1231         struct cb_info *cb_info;
1232         int i;
1233
1234         if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
1235                 ERR("invalid parameter");
1236                 return PKGMGR_R_EINVAL;
1237         }
1238
1239         if (client->pc_type != PC_REQUEST) {
1240                 ERR("client type is not PC_REQUEST");
1241                 return PKGMGR_R_EINVAL;
1242         }
1243
1244         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1245         for (i = 0; i < n_pkgs; i++)
1246                 g_variant_builder_add(builder, "s", pkgids[i]);
1247
1248         ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
1249                         g_variant_new("(uas)", uid, builder), &result);
1250         g_variant_builder_unref(builder);
1251         if (ret != PKGMGR_R_OK) {
1252                 ERR("request failed: %d", ret);
1253                 return ret;
1254         }
1255
1256         g_variant_get(result, "(i&s)", &ret, &req_key);
1257         if (req_key == NULL) {
1258                 g_variant_unref(result);
1259                 return PKGMGR_R_ECOMM;
1260         }
1261         if (ret != PKGMGR_R_OK) {
1262                 g_variant_unref(result);
1263                 return ret;
1264         }
1265
1266         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1267         if (cb_info == NULL) {
1268                 g_variant_unref(result);
1269                 return PKGMGR_R_ERROR;
1270         }
1271         g_variant_unref(result);
1272         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1273         if (ret != PKGMGR_R_OK) {
1274                 __free_cb_info(cb_info);
1275                 return ret;
1276         }
1277         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1278
1279         return cb_info->req_id;
1280 }
1281
1282 API int pkgmgr_client_activate_packages(pkgmgr_client *pc,
1283                 const char *pkg_type, const char **pkgids, int n_pkgs,
1284                 pkgmgr_handler event_cb, void *data)
1285 {
1286         return pkgmgr_client_usr_activate_packages(pc, pkg_type,
1287                         pkgids, n_pkgs, event_cb, data, _getuid());
1288 }
1289
1290 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
1291                                  const char *pkgid, uid_t uid)
1292 {
1293         GVariant *result;
1294         GVariantBuilder *builder;
1295         int ret = PKGMGR_R_ECOMM;
1296         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1297
1298         if (pc == NULL || pkgid == NULL) {
1299                 ERR("invalid parameter");
1300                 return PKGMGR_R_EINVAL;
1301         }
1302
1303         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1304         g_variant_builder_add(builder, "s", pkgid);
1305
1306         ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
1307                         g_variant_new("(uas)", uid, builder), &result);
1308         g_variant_builder_unref(builder);
1309         if (ret != PKGMGR_R_OK) {
1310                 ERR("request failed: %d", ret);
1311                 return ret;
1312         }
1313
1314         g_variant_get(result, "(is)", &ret, NULL);
1315         g_variant_unref(result);
1316
1317         return ret;
1318 }
1319
1320 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
1321                                  const char *pkgid)
1322 {
1323         return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, _getuid());
1324 }
1325
1326 API int pkgmgr_client_usr_deactivate_packages(pkgmgr_client *pc,
1327                 const char *pkg_type, const char **pkgids, int n_pkgs,
1328                 pkgmgr_handler event_cb, void *data, uid_t uid)
1329 {
1330         GVariant *result;
1331         GVariantBuilder *builder;
1332         int ret = PKGMGR_R_ECOMM;
1333         char *req_key = NULL;
1334         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1335         struct cb_info *cb_info;
1336         int i;
1337
1338         if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
1339                 ERR("invalid parameter");
1340                 return PKGMGR_R_EINVAL;
1341         }
1342
1343         if (client->pc_type != PC_REQUEST) {
1344                 ERR("client type is not PC_REQUEST");
1345                 return PKGMGR_R_EINVAL;
1346         }
1347
1348         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1349         for (i = 0; i < n_pkgs; i++)
1350                 g_variant_builder_add(builder, "s", pkgids[i]);
1351
1352         ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
1353                 g_variant_new("(uas)", uid, builder), &result);
1354         g_variant_builder_unref(builder);
1355         if (ret != PKGMGR_R_OK) {
1356                 ERR("request failed: %d", ret);
1357                 return ret;
1358         }
1359
1360         g_variant_get(result, "(i&s)", &ret, &req_key);
1361         if (req_key == NULL) {
1362                 g_variant_unref(result);
1363                 return PKGMGR_R_ECOMM;
1364         }
1365         if (ret != PKGMGR_R_OK) {
1366                 g_variant_unref(result);
1367                 return ret;
1368         }
1369
1370         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1371         if (cb_info == NULL) {
1372                 g_variant_unref(result);
1373                 return PKGMGR_R_ERROR;
1374         }
1375         g_variant_unref(result);
1376         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1377         if (ret != PKGMGR_R_OK) {
1378                 __free_cb_info(cb_info);
1379                 return ret;
1380         }
1381         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1382
1383         return cb_info->req_id;
1384 }
1385
1386 API int pkgmgr_client_deactivate_packages(pkgmgr_client *pc,
1387                 const char *pkg_type, const char **pkgids, int n_pkgs,
1388                 pkgmgr_handler event_cb, void *data)
1389 {
1390         return pkgmgr_client_usr_deactivate_packages(pc, pkg_type,
1391                         pkgids, n_pkgs, event_cb, data, _getuid());
1392 }
1393
1394 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
1395                 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1396 {
1397         GVariant *result;
1398         int ret = PKGMGR_R_ECOMM;
1399         char *req_key = NULL;
1400         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1401         struct cb_info *cb_info;
1402
1403         if (pc == NULL || appid == NULL) {
1404                 ERR("invalid parameter");
1405                 return PKGMGR_R_EINVAL;
1406         }
1407
1408         ret = pkgmgr_client_connection_send_request(client, "enable_app",
1409                         g_variant_new("(us)", uid, appid), &result);
1410         if (ret != PKGMGR_R_OK) {
1411                 ERR("request failed: %d", ret);
1412                 return ret;
1413         }
1414
1415         g_variant_get(result, "(i&s)", &ret, &req_key);
1416         if (req_key == NULL) {
1417                 g_variant_unref(result);
1418                 return PKGMGR_R_ECOMM;
1419         }
1420         if (ret != PKGMGR_R_OK) {
1421                 g_variant_unref(result);
1422                 return ret;
1423         }
1424
1425         cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1426                         req_key);
1427         if (cb_info == NULL) {
1428                 g_variant_unref(result);
1429                 return PKGMGR_R_ENOMEM;
1430         }
1431         g_variant_unref(result);
1432         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1433         if (ret != PKGMGR_R_OK) {
1434                 __free_cb_info(cb_info);
1435                 return ret;
1436         }
1437         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1438
1439         return cb_info->req_id;
1440 }
1441
1442 API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid,
1443                 pkgmgr_app_handler app_event_cb, void *data)
1444 {
1445         return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb,
1446                         data, _getuid());
1447 }
1448
1449 API int pkgmgr_client_usr_activate_apps(pkgmgr_client *pc, const char **appids,
1450                 int n_apps, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1451 {
1452         GVariant *result;
1453         GVariantBuilder *builder;
1454         int ret = PKGMGR_R_ECOMM;
1455         char *req_key = NULL;
1456         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1457         struct cb_info *cb_info;
1458         int i;
1459
1460         if (pc == NULL || appids == NULL || n_apps < 1) {
1461                 ERR("invalid parameter");
1462                 return PKGMGR_R_EINVAL;
1463         }
1464
1465         if (client->pc_type != PC_REQUEST) {
1466                 ERR("client type is not PC_REQUEST");
1467                 return PKGMGR_R_EINVAL;
1468         }
1469
1470         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1471         for (i = 0; i < n_apps; i++)
1472                 g_variant_builder_add(builder, "s", appids[i]);
1473
1474         ret = pkgmgr_client_connection_send_request(client, "enable_apps",
1475                 g_variant_new("(uas)", uid, builder), &result);
1476         g_variant_builder_unref(builder);
1477         if (ret != PKGMGR_R_OK) {
1478                 ERR("request failed: %d", ret);
1479                 return ret;
1480         }
1481
1482         g_variant_get(result, "(i&s)", &ret, &req_key);
1483         if (req_key == NULL) {
1484                 g_variant_unref(result);
1485                 return PKGMGR_R_ECOMM;
1486         }
1487         if (ret != PKGMGR_R_OK) {
1488                 g_variant_unref(result);
1489                 return ret;
1490         }
1491
1492         cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
1493         if (cb_info == NULL) {
1494                 g_variant_unref(result);
1495                 return PKGMGR_R_ERROR;
1496         }
1497         g_variant_unref(result);
1498         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1499         if (ret != PKGMGR_R_OK) {
1500                 __free_cb_info(cb_info);
1501                 return ret;
1502         }
1503         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1504
1505         return cb_info->req_id;
1506 }
1507
1508 API int pkgmgr_client_activate_apps(pkgmgr_client *pc, const char **appids,
1509                 int n_apps, pkgmgr_app_handler app_event_cb, void *data)
1510 {
1511         return pkgmgr_client_usr_activate_apps(pc, appids, n_apps,
1512                         app_event_cb, data, _getuid());
1513 }
1514
1515 API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
1516                 const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1517 {
1518         GVariant *result;
1519         int ret = PKGMGR_R_ECOMM;
1520         char *req_key = NULL;
1521         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1522         struct cb_info *cb_info;
1523
1524         if (pc == NULL || appid == NULL) {
1525                 ERR("invalid parameter");
1526                 return PKGMGR_R_EINVAL;
1527         }
1528
1529         ret = pkgmgr_client_connection_send_request(client,
1530                         "enable_global_app_for_uid",
1531                         g_variant_new("(us)", uid, appid), &result);
1532         if (ret != PKGMGR_R_OK) {
1533                 ERR("request failed: %d", ret);
1534                 return ret;
1535         }
1536
1537         g_variant_get(result, "(i&s)", &ret, &req_key);
1538         if (req_key == NULL) {
1539                 g_variant_unref(result);
1540                 return PKGMGR_R_ECOMM;
1541         }
1542         if (ret != PKGMGR_R_OK) {
1543                 g_variant_unref(result);
1544                 return ret;
1545         }
1546
1547         cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1548                         req_key);
1549         if (cb_info == NULL) {
1550                 g_variant_unref(result);
1551                 return PKGMGR_R_ENOMEM;
1552         }
1553         g_variant_unref(result);
1554         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1555         if (ret != PKGMGR_R_OK) {
1556                 __free_cb_info(cb_info);
1557                 return ret;
1558         }
1559         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1560
1561         return cb_info->req_id;
1562 }
1563
1564 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1565                 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1566 {
1567         GVariant *result;
1568         int ret = PKGMGR_R_ECOMM;
1569         char *req_key = NULL;
1570         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1571         struct cb_info *cb_info;
1572
1573         if (pc == NULL || appid == NULL) {
1574                 ERR("invalid parameter");
1575                 return PKGMGR_R_EINVAL;
1576         }
1577
1578         ret = pkgmgr_client_connection_send_request(client, "disable_app",
1579                         g_variant_new("(us)", uid, appid), &result);
1580         if (ret != PKGMGR_R_OK) {
1581                 ERR("request failed: %d", ret);
1582                 return ret;
1583         }
1584
1585         g_variant_get(result, "(i&s)", &ret, &req_key);
1586         if (req_key == NULL) {
1587                 g_variant_unref(result);
1588                 return PKGMGR_R_ECOMM;
1589         }
1590         if (ret != PKGMGR_R_OK) {
1591                 g_variant_unref(result);
1592                 return ret;
1593         }
1594
1595         cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1596                         req_key);
1597         if (cb_info == NULL) {
1598                 g_variant_unref(result);
1599                 return PKGMGR_R_ENOMEM;
1600         }
1601         g_variant_unref(result);
1602         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1603         if (ret != PKGMGR_R_OK) {
1604                 __free_cb_info(cb_info);
1605                 return ret;
1606         }
1607         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1608
1609         return cb_info->req_id;
1610 }
1611
1612 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid,
1613                 pkgmgr_app_handler app_event_cb, void *data)
1614 {
1615         return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb, data,
1616                         _getuid());
1617 }
1618
1619 API int pkgmgr_client_usr_deactivate_apps(pkgmgr_client *pc,
1620                 const char **appids, int n_apps,
1621                 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1622 {
1623         GVariant *result;
1624         GVariantBuilder *builder;
1625         int ret = PKGMGR_R_ECOMM;
1626         char *req_key = NULL;
1627         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1628         struct cb_info *cb_info;
1629         int i;
1630
1631         if (pc == NULL || appids == NULL || n_apps < 1) {
1632                 ERR("invalid parameter");
1633                 return PKGMGR_R_EINVAL;
1634         }
1635
1636         if (client->pc_type != PC_REQUEST) {
1637                 ERR("client type is not PC_REQUEST");
1638                 return PKGMGR_R_EINVAL;
1639         }
1640
1641         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1642         for (i = 0; i < n_apps; i++)
1643                 g_variant_builder_add(builder, "s", appids[i]);
1644
1645         ret = pkgmgr_client_connection_send_request(client, "disable_apps",
1646                 g_variant_new("(uas)", uid, builder), &result);
1647         g_variant_builder_unref(builder);
1648         if (ret != PKGMGR_R_OK) {
1649                 ERR("request failed: %d", ret);
1650                 return ret;
1651         }
1652
1653         g_variant_get(result, "(i&s)", &ret, &req_key);
1654         if (req_key == NULL) {
1655                 g_variant_unref(result);
1656                 return PKGMGR_R_ECOMM;
1657         }
1658         if (ret != PKGMGR_R_OK) {
1659                 g_variant_unref(result);
1660                 return ret;
1661         }
1662
1663         cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
1664         if (cb_info == NULL) {
1665                 g_variant_unref(result);
1666                 return PKGMGR_R_ERROR;
1667         }
1668         g_variant_unref(result);
1669         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1670         if (ret != PKGMGR_R_OK) {
1671                 __free_cb_info(cb_info);
1672                 return ret;
1673         }
1674         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1675
1676         return cb_info->req_id;
1677 }
1678
1679 API int pkgmgr_client_deactivate_apps(pkgmgr_client *pc, const char **appids,
1680                 int n_apps, pkgmgr_app_handler app_event_cb, void *data)
1681 {
1682         return pkgmgr_client_usr_deactivate_apps(pc, appids, n_apps,
1683                         app_event_cb, data, _getuid());
1684 }
1685
1686 API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
1687                 const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1688 {
1689         GVariant *result;
1690         int ret = PKGMGR_R_ECOMM;
1691         char *req_key = NULL;
1692         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1693         struct cb_info *cb_info;
1694
1695         if (pc == NULL || appid == NULL) {
1696                 ERR("invalid parameter");
1697                 return PKGMGR_R_EINVAL;
1698         }
1699
1700         ret = pkgmgr_client_connection_send_request(client,
1701                         "disable_global_app_for_uid",
1702                         g_variant_new("(us)", uid, appid), &result);
1703         if (ret != PKGMGR_R_OK) {
1704                 ERR("request failed: %d", ret);
1705                 return ret;
1706         }
1707
1708         g_variant_get(result, "(i&s)", &ret, &req_key);
1709         if (req_key == NULL) {
1710                 g_variant_unref(result);
1711                 return PKGMGR_R_ECOMM;
1712         }
1713         if (ret != PKGMGR_R_OK) {
1714                 g_variant_unref(result);
1715                 return ret;
1716         }
1717
1718         cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1719                         req_key);
1720         if (cb_info == NULL) {
1721                 g_variant_unref(result);
1722                 return PKGMGR_R_ENOMEM;
1723         }
1724         g_variant_unref(result);
1725         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1726         if (ret != PKGMGR_R_OK) {
1727                 __free_cb_info(cb_info);
1728                 return ret;
1729         }
1730         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1731
1732         return cb_info->req_id;
1733 }
1734
1735 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1736                 const char *pkg_type, const char *appid, pkgmgr_mode mode,
1737                 uid_t uid)
1738 {
1739         GVariant *result;
1740         int ret;
1741         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1742
1743         if (pc == NULL || appid == NULL || uid == GLOBAL_USER) {
1744                 ERR("invalid parameter");
1745                 return PKGMGR_R_EINVAL;
1746         }
1747
1748         if (client->pc_type != PC_REQUEST) {
1749                 ERR("client->pc_type is not PC_REQUEST");
1750                 return PKGMGR_R_EINVAL;
1751         }
1752
1753         ret = pkgmgr_client_connection_send_request(client, "cleardata",
1754                         g_variant_new("(us)", uid, appid), &result);
1755         if (ret != PKGMGR_R_OK) {
1756                 ERR("request failed: %d", ret);
1757                 return ret;
1758         }
1759
1760         g_variant_get(result, "(i)", &ret);
1761         g_variant_unref(result);
1762
1763         return ret;
1764 }
1765
1766 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1767                 const char *appid, pkgmgr_mode mode)
1768 {
1769         return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid, mode,
1770                         _getuid());
1771 }
1772
1773 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1774 {
1775         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1776
1777         if (pc == NULL) {
1778                 ERR("invalid parameter");
1779                 return PKGMGR_R_EINVAL;
1780         }
1781
1782         client->status_type = status_type;
1783
1784         return PKGMGR_R_OK;
1785 }
1786
1787 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1788                 void *data)
1789 {
1790         int ret;
1791         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1792         struct cb_info *cb_info;
1793
1794         if (pc == NULL || event_cb == NULL) {
1795                 ERR("invalid parameter");
1796                 return PKGMGR_R_EINVAL;
1797         }
1798
1799         if (client->pc_type != PC_LISTENING) {
1800                 ERR("client->pc_type is not PC_LISTENING");
1801                 return PKGMGR_R_EINVAL;
1802         }
1803
1804         cb_info = __create_event_cb_info(client, event_cb, data, NULL);
1805         if (cb_info == NULL)
1806                 return PKGMGR_R_ENOMEM;
1807         cb_info->status_type = client->status_type;
1808         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1809         if (ret != PKGMGR_R_OK) {
1810                 __free_cb_info(cb_info);
1811                 return ret;
1812         }
1813         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1814
1815         return cb_info->req_id;
1816 }
1817
1818 API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
1819                 pkgmgr_app_handler app_event_cb, void *data)
1820 {
1821         int ret;
1822         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1823         struct cb_info *cb_info;
1824
1825         if (pc == NULL || app_event_cb == NULL) {
1826                 ERR("invalid parameter");
1827                 return PKGMGR_R_EINVAL;
1828         }
1829
1830         if (client->pc_type != PC_LISTENING) {
1831                 ERR("client->pc_type is not PC_LISTENING");
1832                 return PKGMGR_R_EINVAL;
1833         }
1834
1835         cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL);
1836         if (cb_info == NULL)
1837                 return PKGMGR_R_ENOMEM;
1838         cb_info->status_type = client->status_type;
1839         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1840         if (ret != PKGMGR_R_OK) {
1841                 __free_cb_info(cb_info);
1842                 return ret;
1843         }
1844         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1845
1846         return cb_info->req_id;
1847 }
1848
1849 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
1850 {
1851         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1852         GList *tmp;
1853         GList *next;
1854         struct cb_info *cb_info;
1855
1856         if (pc == NULL) {
1857                 ERR("invalid parameter");
1858                 return PKGMGR_R_EINVAL;
1859         }
1860
1861         /* unset all callback */
1862         tmp = client->cb_info_list;
1863         while (tmp != NULL) {
1864                 next = tmp->next;
1865                 cb_info = (struct cb_info *)tmp->data;
1866                 pkgmgr_client_connection_unset_callback(pc, cb_info);
1867                 client->cb_info_list = g_list_delete_link(client->cb_info_list,
1868                                 tmp);
1869                 __free_cb_info(cb_info);
1870                 tmp = next;
1871         }
1872
1873         return PKGMGR_R_OK;
1874 }
1875
1876 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1877                 const char *pkgid, const char *key, const char *val)
1878 {
1879         /* client cannot broadcast signal */
1880         return PKGMGR_R_OK;
1881 }
1882
1883 /* TODO: deprecate(or remove) */
1884 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
1885                 int service_mode, pkgmgr_client *pc, const char *pkg_type,
1886                 const char *pkgid, const char *custom_info,
1887                 pkgmgr_handler event_cb, void *data)
1888 {
1889         return pkgmgr_client_usr_request_service(service_type, service_mode,
1890                         pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
1891                         data);
1892 }
1893
1894 API int pkgmgr_client_usr_request_service(
1895                 pkgmgr_request_service_type service_type, int service_mode,
1896                 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
1897                 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
1898                 void *data)
1899 {
1900         int ret = 0;
1901
1902         /* Check for NULL value of service type */
1903         retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1904         retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1905
1906         switch (service_type) {
1907         case PM_REQUEST_MOVE:
1908                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1909                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1910                 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_EXTENDED), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1911
1912                 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1913                 break;
1914
1915         case PM_REQUEST_GET_SIZE:
1916                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1917                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1918                 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1919
1920                 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1921                 break;
1922
1923         case PM_REQUEST_KILL_APP:
1924         case PM_REQUEST_CHECK_APP:
1925                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1926                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1927
1928                 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1929                 if (ret < 0)
1930                         ERR("__check_app_process fail \n");
1931                 else
1932                         ret = PKGMGR_R_OK;
1933
1934                 break;
1935
1936         default:
1937                 ERR("Wrong Request\n");
1938                 ret = -1;
1939                 break;
1940         }
1941
1942 catch:
1943
1944         return ret;
1945 }
1946
1947 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1948 {
1949         GVariant *result;
1950         int ret;
1951         struct pkgmgr_client_t *client;
1952
1953         if (pkgid == NULL || uid == GLOBAL_USER) {
1954                 ERR("invalid parameter");
1955                 return PKGMGR_R_EINVAL;
1956         }
1957
1958         client = pkgmgr_client_new(PC_REQUEST);
1959         if (client == NULL) {
1960                 ERR("out of memory");
1961                 return PKGMGR_R_ENOMEM;
1962         }
1963
1964         ret = pkgmgr_client_connection_send_request(client, "clearcache",
1965                         g_variant_new("(us)", uid, pkgid), &result);
1966         if (ret != PKGMGR_R_OK) {
1967                 ERR("request failed: %d", ret);
1968                 pkgmgr_client_free(client);
1969                 return ret;
1970         }
1971
1972         g_variant_get(result, "(i)", &ret);
1973         g_variant_unref(result);
1974         pkgmgr_client_free(client);
1975
1976         return ret;
1977 }
1978
1979 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1980 {
1981         return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
1982 }
1983
1984 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1985 {
1986         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1987 }
1988
1989 API int pkgmgr_client_clear_all_cache_dir(void)
1990 {
1991         return pkgmgr_client_usr_clear_cache_dir(
1992                         PKG_CLEAR_ALL_CACHE, _getuid());
1993 }
1994
1995 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
1996                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1997                 void *data)
1998 {
1999         return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
2000                         _getuid());
2001 }
2002
2003 /* TODO: deprecate(or remove) */
2004 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
2005                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
2006                 void *data, uid_t uid)
2007 {
2008         GVariant *result;
2009         int ret = PKGMGR_R_ECOMM;
2010         char *req_key = NULL;
2011         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2012         struct cb_info *cb_info;
2013
2014         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
2015                 ERR("invalid parameter");
2016                 return PKGMGR_R_EINVAL;
2017         }
2018
2019         if (client->pc_type != PC_REQUEST) {
2020                 ERR("client->pc_type is not PC_REQUEST");
2021                 return PKGMGR_R_EINVAL;
2022         }
2023
2024         /* FIXME */
2025         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
2026                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
2027         else
2028                 get_type = PM_GET_PKG_SIZE_INFO;
2029
2030         ret = pkgmgr_client_connection_send_request(client, "getsize",
2031                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
2032         if (ret != PKGMGR_R_OK) {
2033                 ERR("request failed: %d", ret);
2034                 return ret;
2035         }
2036
2037         g_variant_get(result, "(i&s)", &ret, &req_key);
2038         if (req_key == NULL) {
2039                 g_variant_unref(result);
2040                 return PKGMGR_R_ECOMM;
2041         }
2042         if (ret != PKGMGR_R_OK) {
2043                 g_variant_unref(result);
2044                 return ret;
2045         }
2046
2047         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
2048         if (cb_info == NULL) {
2049                 g_variant_unref(result);
2050                 return PKGMGR_R_ENOMEM;
2051         }
2052         g_variant_unref(result);
2053         ret = pkgmgr_client_connection_set_callback(client, cb_info);
2054         if (ret != PKGMGR_R_OK) {
2055                 __free_cb_info(cb_info);
2056                 return ret;
2057         }
2058         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2059
2060         return PKGMGR_R_OK;
2061 }
2062
2063 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
2064                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
2065                 void *user_data, uid_t uid)
2066 {
2067         GVariant *result;
2068         int ret = PKGMGR_R_ECOMM;
2069         char *req_key = NULL;
2070         int get_type;
2071         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2072         struct cb_info *cb_info;
2073
2074         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
2075                 ERR("invalid parameter");
2076                 return PKGMGR_R_EINVAL;
2077         }
2078
2079         if (client->pc_type != PC_REQUEST) {
2080                 ERR("client->pc_type is not PC_REQUEST");
2081                 return PKGMGR_R_EINVAL;
2082         }
2083
2084         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
2085                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
2086         else
2087                 get_type = PM_GET_PKG_SIZE_INFO;
2088
2089         ret = pkgmgr_client_connection_send_request(client, "getsize",
2090                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
2091         if (ret != PKGMGR_R_OK) {
2092                 ERR("request failed: %d", ret);
2093                 return ret;
2094         }
2095
2096         g_variant_get(result, "(i&s)", &ret, &req_key);
2097         if (req_key == NULL) {
2098                 g_variant_unref(result);
2099                 return PKGMGR_R_ECOMM;
2100         }
2101         if (ret != PKGMGR_R_OK) {
2102                 g_variant_unref(result);
2103                 return ret;
2104         }
2105
2106         cb_info = __create_size_info_cb_info(client, event_cb, user_data,
2107                         req_key);
2108         if (cb_info == NULL) {
2109                 g_variant_unref(result);
2110                 return PKGMGR_R_ENOMEM;
2111         }
2112         g_variant_unref(result);
2113         ret = pkgmgr_client_connection_set_callback(client, cb_info);
2114         if (ret != PKGMGR_R_OK) {
2115                 __free_cb_info(cb_info);
2116                 return ret;
2117         }
2118         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2119
2120         return PKGMGR_R_OK;
2121 }
2122
2123 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
2124                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
2125                 void *user_data)
2126 {
2127         return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
2128                         user_data, _getuid());
2129 }
2130
2131 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
2132                 pkgmgr_total_pkg_size_info_receive_cb event_cb,
2133                 void *user_data, uid_t uid)
2134 {       /* total package size info */
2135         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
2136                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
2137                         user_data, uid);
2138 }
2139
2140 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
2141                 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
2142 {
2143         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
2144                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
2145                         user_data, _getuid());
2146 }
2147
2148 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
2149                 const char *resp_data, char **req_data, char **license_url)
2150 {
2151         GVariant *result;
2152         int ret;
2153         char *data;
2154         char *url;
2155         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2156
2157         if (pc == NULL || resp_data == NULL || req_data == NULL ||
2158                         license_url == NULL) {
2159                 ERR("invalid parameter");
2160                 return PKGMGR_R_EINVAL;
2161         }
2162
2163         if (client->pc_type != PC_REQUEST) {
2164                 ERR("client->pc_type is not PC_REQUEST");
2165                 return PKGMGR_R_EINVAL;
2166         }
2167
2168         ret = pkgmgr_client_connection_send_request(client,
2169                         "generate_license_request",
2170                         g_variant_new("(s)", resp_data), &result);
2171         if (ret != PKGMGR_R_OK) {
2172                 ERR("request failed: %d", ret);
2173                 return ret;
2174         }
2175
2176         g_variant_get(result, "(i&s&s)", &ret, &data, &url);
2177         if (ret != PKGMGR_R_OK) {
2178                 ERR("generate_license_request failed: %d", ret);
2179                 g_variant_unref(result);
2180                 return ret;
2181         }
2182
2183         *req_data = strdup(data);
2184         *license_url = strdup(url);
2185
2186         g_variant_unref(result);
2187
2188         return PKGMGR_R_OK;
2189 }
2190
2191 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
2192 {
2193         GVariant *result;
2194         int ret;
2195         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2196
2197         if (pc == NULL || resp_data == NULL) {
2198                 ERR("invalid parameter");
2199                 return PKGMGR_R_EINVAL;
2200         }
2201
2202         if (client->pc_type != PC_REQUEST) {
2203                 ERR("client->pc_type is not PC_REQUEST");
2204                 return PKGMGR_R_EINVAL;
2205         }
2206
2207         ret = pkgmgr_client_connection_send_request(client, "register_license",
2208                         g_variant_new("(s)", resp_data), &result);
2209         if (ret != PKGMGR_R_OK) {
2210                 ERR("request failed: %d", ret);
2211                 return ret;
2212         }
2213
2214         g_variant_get(result, "(i)", &ret);
2215         g_variant_unref(result);
2216         if (ret != PKGMGR_R_OK)
2217                 ERR("register license failed: %d", ret);
2218
2219         return ret;
2220 }
2221
2222 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
2223                 const char *drm_file_path, const char *decrypted_file_path)
2224 {
2225         GVariant *result;
2226         int ret;
2227         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2228
2229         if (pc == NULL || drm_file_path == NULL ||
2230                         decrypted_file_path == NULL) {
2231                 ERR("invalid parameter");
2232                 return PKGMGR_R_EINVAL;
2233         }
2234
2235         if (client->pc_type != PC_REQUEST) {
2236                 ERR("client->pc_type is not PC_REQUEST");
2237                 return PKGMGR_R_EINVAL;
2238         }
2239
2240         ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
2241                         g_variant_new("(ss)", drm_file_path,
2242                                 decrypted_file_path), &result);
2243         if (ret != PKGMGR_R_OK) {
2244                 ERR("request failed: %d", ret);
2245                 return ret;
2246         }
2247
2248         g_variant_get(result, "(i)", &ret);
2249         g_variant_unref(result);
2250         if (ret != PKGMGR_R_OK)
2251                 ERR("decrypt_package failed: %d", ret);
2252
2253         return ret;
2254 }
2255
2256 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
2257 {
2258         return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
2259 }
2260
2261 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
2262                 const char *appid, uid_t uid)
2263 {
2264         int ret;
2265         GVariant *result;
2266         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2267
2268         if (pc == NULL || appid == NULL) {
2269                 ERR("Invalid parameter");
2270                 return PKGMGR_R_EINVAL;
2271         }
2272
2273         ret = pkgmgr_client_connection_send_request(client,
2274                         "enable_app_splash_screen",
2275                         g_variant_new("(us)", uid, appid), &result);
2276         if (ret != PKGMGR_R_OK) {
2277                 ERR("request failed: %d", ret);
2278                 return ret;
2279         }
2280
2281         g_variant_get(result, "(i)", &ret);
2282         g_variant_unref(result);
2283         if (ret != PKGMGR_R_OK)
2284                 ERR("enable splash screen failed: %d", ret);
2285
2286         return ret;
2287 }
2288
2289 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
2290                 const char *appid)
2291 {
2292         return pkgmgr_client_usr_disable_splash_screen(pc, appid,
2293                         _getuid());
2294 }
2295
2296 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
2297                 const char *appid, uid_t uid)
2298 {
2299         int ret;
2300         GVariant *result;
2301         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2302
2303         if (pc == NULL || appid == NULL) {
2304                 ERR("Invalid parameter");
2305                 return PKGMGR_R_EINVAL;
2306         }
2307
2308         ret = pkgmgr_client_connection_send_request(client,
2309                         "disable_app_splash_screen",
2310                         g_variant_new("(us)", uid, appid), &result);
2311         if (ret != PKGMGR_R_OK) {
2312                 ERR("request failed: %d", ret);
2313                 return ret;
2314         }
2315
2316         g_variant_get(result, "(i)", &ret);
2317         g_variant_unref(result);
2318         if (ret != PKGMGR_R_OK)
2319                 ERR("disable splash screen failed: %d", ret);
2320
2321         return ret;
2322 }
2323
2324 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2325                 int mode, uid_t uid)
2326 {
2327         GVariant *result;
2328         int ret = PKGMGR_R_ECOMM;
2329         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2330
2331         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2332                 ERR("invalid parameter");
2333                 return PKGMGR_R_EINVAL;
2334         }
2335
2336         ret = pkgmgr_client_connection_send_request(client,
2337                         "set_restriction_mode",
2338                         g_variant_new("(usi)", uid, pkgid, mode), &result);
2339         if (ret != PKGMGR_R_OK) {
2340                 ERR("request failed: %d", ret);
2341                 return ret;
2342         }
2343
2344         g_variant_get(result, "(i)", &ret);
2345         g_variant_unref(result);
2346
2347         return ret;
2348 }
2349
2350 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
2351                 const char *pkgid, int mode, uid_t uid)
2352 {
2353         return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
2354 }
2355
2356 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
2357                 const char *pkgid, int mode)
2358 {
2359         return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
2360                         _getuid());
2361 }
2362
2363 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2364                 int mode, uid_t uid)
2365 {
2366         GVariant *result;
2367         int ret = PKGMGR_R_ECOMM;
2368         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2369
2370         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2371                 ERR("invalid parameter");
2372                 return PKGMGR_R_EINVAL;
2373         }
2374
2375         ret = pkgmgr_client_connection_send_request(client,
2376                         "unset_restriction_mode",
2377                         g_variant_new("(usi)", uid, pkgid, mode), &result);
2378         if (ret != PKGMGR_R_OK) {
2379                 ERR("request failed: %d", ret);
2380                 return ret;
2381         }
2382
2383         g_variant_get(result, "(i)", &ret);
2384         g_variant_unref(result);
2385
2386         return ret;
2387
2388 }
2389
2390 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
2391                 const char *pkgid, int mode, uid_t uid)
2392 {
2393         return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
2394 }
2395
2396 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
2397                 const char *pkgid, int mode)
2398 {
2399         return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
2400                         _getuid());
2401 }
2402
2403 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2404                 int *mode, uid_t uid)
2405 {
2406         GVariant *result;
2407         int ret = PKGMGR_R_ECOMM;
2408         gint m;
2409         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2410
2411         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
2412                 ERR("invalid parameter");
2413                 return PKGMGR_R_EINVAL;
2414         }
2415
2416         ret = pkgmgr_client_connection_send_request(client,
2417                         "get_restriction_mode",
2418                         g_variant_new("(us)", uid, pkgid), &result);
2419         if (ret != PKGMGR_R_OK) {
2420                 ERR("request failed: %d", ret);
2421                 return ret;
2422         }
2423
2424         g_variant_get(result, "(ii)", &m, &ret);
2425         g_variant_unref(result);
2426         if (ret != PKGMGR_R_OK)
2427                 return ret;
2428
2429         *mode = m;
2430
2431         return PKGMGR_R_OK;
2432 }
2433
2434 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
2435                 const char *pkgid, int *mode, uid_t uid)
2436 {
2437         return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
2438 }
2439
2440 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
2441                 const char *pkgid, int *mode)
2442 {
2443         return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
2444                         _getuid());
2445 }
2446
2447 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
2448                 uid_t uid)
2449 {
2450         GVariant *result;
2451         int ret = PKGMGR_R_ECOMM;
2452         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2453
2454         if (pc == NULL) {
2455                 ERR("invalid parameter");
2456                 return PKGMGR_R_EINVAL;
2457         }
2458
2459         ret = pkgmgr_client_connection_send_request(client,
2460                         "set_restriction_mode",
2461                         g_variant_new("(usi)", uid, "", mode), &result);
2462         if (ret != PKGMGR_R_OK) {
2463                 ERR("request failed: %d", ret);
2464                 return ret;
2465         }
2466
2467         g_variant_get(result, "(i)", &ret);
2468         g_variant_unref(result);
2469
2470         return ret;
2471 }
2472
2473 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
2474 {
2475         return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
2476 }
2477
2478 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
2479                 uid_t uid)
2480 {
2481         GVariant *result;
2482         int ret = PKGMGR_R_ECOMM;
2483         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2484
2485         if (pc == NULL) {
2486                 ERR("invalid parameter");
2487                 return PKGMGR_R_EINVAL;
2488         }
2489
2490         ret = pkgmgr_client_connection_send_request(client,
2491                         "unset_restriction_mode",
2492                         g_variant_new("(usi)", uid, "", mode), &result);
2493         if (ret != PKGMGR_R_OK) {
2494                 ERR("request failed: %d", ret);
2495                 return ret;
2496         }
2497
2498         g_variant_get(result, "(i)", &ret);
2499         g_variant_unref(result);
2500
2501         return ret;
2502 }
2503
2504 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
2505 {
2506         return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
2507 }
2508
2509 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
2510                 int *mode, uid_t uid)
2511 {
2512         GVariant *result;
2513         int ret = PKGMGR_R_ECOMM;
2514         gint m;
2515         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2516
2517         if (pc == NULL) {
2518                 ERR("invalid parameter");
2519                 return PKGMGR_R_EINVAL;
2520         }
2521
2522         ret = pkgmgr_client_connection_send_request(client,
2523                         "get_restriction_mode",
2524                         g_variant_new("(us)", uid, ""), &result);
2525         if (ret != PKGMGR_R_OK) {
2526                 ERR("request failed: %d", ret);
2527                 return ret;
2528         }
2529
2530         g_variant_get(result, "(ii)", &m, &ret);
2531         g_variant_unref(result);
2532         if (ret != PKGMGR_R_OK)
2533                 return ret;
2534
2535         *mode = m;
2536
2537         return PKGMGR_R_OK;
2538 }
2539
2540 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
2541 {
2542         return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
2543 }
2544
2545 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
2546 {
2547         int ret;
2548         pkg_plugin_set *plugin_set;
2549         package_manager_pkg_detail_info_t *info;
2550         char *pkg_type;
2551
2552         if (pkg_path == NULL) {
2553                 ERR("invalid parameter");
2554                 return NULL;
2555         }
2556
2557         pkg_type = __get_type_from_path(pkg_path);
2558         if (pkg_type == NULL) {
2559                 ERR("cannot get pkg type");
2560                 return NULL;
2561         }
2562
2563         plugin_set = _package_manager_load_library(pkg_type);
2564         if (plugin_set == NULL) {
2565                 ERR("failed to load library for %s", pkg_type);
2566                 free(pkg_type);
2567                 return NULL;
2568         }
2569
2570         info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2571         if (info == NULL) {
2572                 ERR("out of memory");
2573                 free(pkg_type);
2574                 return NULL;
2575         }
2576
2577         ret = plugin_set->get_pkg_detail_info_from_package(pkg_path, info);
2578         if (ret) {
2579                 ERR("get_pkg_detail_info_from_package failed");
2580                 free(info);
2581                 free(pkg_type);
2582                 return NULL;
2583         }
2584
2585         free(pkg_type);
2586
2587         return (pkgmgr_info *)info;
2588 }
2589
2590 API int pkgmgr_client_free_pkginfo(pkgmgr_info *info)
2591 {
2592         package_manager_pkg_detail_info_t *pkg_info =
2593                 (package_manager_pkg_detail_info_t *)info;
2594
2595         if (info == NULL) {
2596                 ERR("invalid parameter");
2597                 return PKGMGR_R_EINVAL;
2598         }
2599
2600         g_list_free_full(pkg_info->privilege_list, free);
2601         free(pkg_info->icon_buf);
2602         free(pkg_info);
2603
2604         return PKGMGR_R_OK;
2605 }
2606
2607 API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid,
2608                 char *label, uid_t uid)
2609 {
2610         GVariant *result;
2611         int ret = -1;
2612         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2613
2614         if (pc == NULL || appid == NULL || label == NULL) {
2615                 ERR("Invalid parameter");
2616                 return PKGMGR_R_EINVAL;
2617         }
2618
2619         ret = pkgmgr_client_connection_send_request(client,
2620                         "set_app_label",
2621                         g_variant_new("(uss)", uid, appid, label), &result);
2622         if (ret != PKGMGR_R_OK) {
2623                 ERR("Request failed: %d", ret);
2624                 return ret;
2625         }
2626
2627         g_variant_get(result, "(i)", &ret);
2628         g_variant_unref(result);
2629
2630         return ret;
2631 }
2632
2633 API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label)
2634 {
2635         return pkgmgr_client_usr_set_app_label(pc, appid, label, _getuid());
2636 }
2637
2638 API int pkgmgr_client_usr_set_app_icon(pkgmgr_client *pc, char *appid,
2639                 char *icon_path, uid_t uid)
2640 {
2641         GVariant *result;
2642         int ret = -1;
2643         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2644
2645         if (pc == NULL || appid == NULL || icon_path == NULL) {
2646                 ERR("Invalid parameter");
2647                 return PKGMGR_R_EINVAL;
2648         }
2649
2650         if (access(icon_path, F_OK) != 0) {
2651                 ERR("failed to access: %s", icon_path);
2652                 return PKGMGR_R_EINVAL;
2653         }
2654
2655         ret = pkgmgr_client_connection_send_request(client,
2656                         "set_app_icon",
2657                         g_variant_new("(uss)", uid, appid, icon_path), &result);
2658         if (ret != PKGMGR_R_OK) {
2659                 ERR("Request failed: %d", ret);
2660                 return ret;
2661         }
2662
2663         g_variant_get(result, "(i)", &ret);
2664         g_variant_unref(result);
2665
2666         return ret;
2667 }
2668
2669 API int pkgmgr_client_set_app_icon(pkgmgr_client *pc, char *appid, char *icon_path)
2670 {
2671         return pkgmgr_client_usr_set_app_icon(pc, appid, icon_path, _getuid());
2672 }
2673
2674 API int pkgmgr_client_set_debug_mode(pkgmgr_client *pc, bool debug_mode)
2675 {
2676         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2677
2678         if (pc == NULL) {
2679                 ERR("invalid parameter");
2680                 return PKGMGR_R_EINVAL;
2681         }
2682
2683         client->debug_mode = debug_mode;
2684
2685         return PKGMGR_R_OK;
2686 }
2687
2688 API int pkgmgr_client_set_skip_optimization(pkgmgr_client *pc, bool skip_optimization)
2689 {
2690         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2691
2692         if (pc == NULL) {
2693                 ERR("invalid parameter");
2694                 return PKGMGR_R_EINVAL;
2695         }
2696
2697         client->skip_optimization = skip_optimization;
2698
2699         return PKGMGR_R_OK;
2700 }
2701
2702 API int pkgmgr_client_usr_migrate_external_image(pkgmgr_client *pc,
2703                 const char *pkgid, uid_t uid)
2704 {
2705         GVariant *result;
2706         int ret = PKGMGR_R_ECOMM;
2707         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2708
2709         if (pc == NULL) {
2710                 ERR("invalid parameter");
2711                 return PKGMGR_R_EINVAL;
2712         }
2713
2714         ret = pkgmgr_client_connection_send_request(client,
2715                         "migrate_external_image",
2716                         g_variant_new("(us)", uid, pkgid), &result);
2717         if (ret != PKGMGR_R_OK) {
2718                 ERR("request failed: %d", ret);
2719                 return ret;
2720         }
2721
2722         g_variant_get(result, "(i)", &ret);
2723         g_variant_unref(result);
2724
2725         return ret;
2726 }