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