client/src/pkgmgr.c

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