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