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