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