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