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_copy_event_cb_info(
 146                 struct pkgmgr_client_t *client,
 147                 pkgmgr_res_copy_handler res_copy_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_copy_event_cb = res_copy_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_set_status_type(pkgmgr_client *pc, int status_type)
1813 {
1814         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1815
1816         if (pc == NULL) {
1817                 ERR("invalid parameter");
1818                 return PKGMGR_R_EINVAL;
1819         }
1820
1821         client->status_type = status_type;
1822
1823         return PKGMGR_R_OK;
1824 }
1825
1826 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1827                 void *data)
1828 {
1829         int ret;
1830         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1831         struct cb_info *cb_info;
1832
1833         if (pc == NULL || event_cb == NULL) {
1834                 ERR("invalid parameter");
1835                 return PKGMGR_R_EINVAL;
1836         }
1837
1838         if (client->pc_type != PC_LISTENING) {
1839                 ERR("client->pc_type is not PC_LISTENING");
1840                 return PKGMGR_R_EINVAL;
1841         }
1842
1843         cb_info = __create_event_cb_info(client, event_cb, data, NULL);
1844         if (cb_info == NULL)
1845                 return PKGMGR_R_ENOMEM;
1846         cb_info->status_type = client->status_type;
1847         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1848         if (ret != PKGMGR_R_OK) {
1849                 __free_cb_info(cb_info);
1850                 return ret;
1851         }
1852         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1853
1854         return cb_info->req_id;
1855 }
1856
1857 API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
1858                 pkgmgr_app_handler app_event_cb, void *data)
1859 {
1860         int ret;
1861         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1862         struct cb_info *cb_info;
1863
1864         if (pc == NULL || app_event_cb == NULL) {
1865                 ERR("invalid parameter");
1866                 return PKGMGR_R_EINVAL;
1867         }
1868
1869         if (client->pc_type != PC_LISTENING) {
1870                 ERR("client->pc_type is not PC_LISTENING");
1871                 return PKGMGR_R_EINVAL;
1872         }
1873
1874         cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL);
1875         if (cb_info == NULL)
1876                 return PKGMGR_R_ENOMEM;
1877         cb_info->status_type = client->status_type;
1878         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1879         if (ret != PKGMGR_R_OK) {
1880                 __free_cb_info(cb_info);
1881                 return ret;
1882         }
1883         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1884
1885         return cb_info->req_id;
1886 }
1887
1888 API int pkgmgr_client_listen_res_copy_status(pkgmgr_client *pc,
1889                 pkgmgr_res_copy_handler event_cb, void *data)
1890 {
1891         int ret;
1892         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1893         struct cb_info *cb_info;
1894
1895         if (pc == NULL || event_cb == NULL) {
1896                 ERR("invalid parameter");
1897                 return PKGMGR_R_EINVAL;
1898         }
1899
1900         if (client->pc_type != PC_LISTENING) {
1901                 ERR("client->pc_type is not PC_LISTENING");
1902                 return PKGMGR_R_EINVAL;
1903         }
1904
1905         cb_info = __create_res_copy_event_cb_info(client, event_cb, data, NULL);
1906         if (cb_info == NULL)
1907                 return PKGMGR_R_ENOMEM;
1908         cb_info->status_type = client->status_type;
1909         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1910         if (ret != PKGMGR_R_OK) {
1911                 __free_cb_info(cb_info);
1912                 return ret;
1913         }
1914         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1915
1916         return cb_info->req_id;
1917 }
1918
1919 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
1920 {
1921         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1922         GList *tmp;
1923         GList *next;
1924         struct cb_info *cb_info;
1925
1926         if (pc == NULL) {
1927                 ERR("invalid parameter");
1928                 return PKGMGR_R_EINVAL;
1929         }
1930
1931         /* unset all callback */
1932         tmp = client->cb_info_list;
1933         while (tmp != NULL) {
1934                 next = tmp->next;
1935                 cb_info = (struct cb_info *)tmp->data;
1936                 pkgmgr_client_connection_unset_callback(pc, cb_info);
1937                 client->cb_info_list = g_list_delete_link(client->cb_info_list,
1938                                 tmp);
1939                 __free_cb_info(cb_info);
1940                 tmp = next;
1941         }
1942
1943         return PKGMGR_R_OK;
1944 }
1945
1946 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1947                 const char *pkgid, const char *key, const char *val)
1948 {
1949         /* client cannot broadcast signal */
1950         return PKGMGR_R_OK;
1951 }
1952
1953 /* TODO: deprecate(or remove) */
1954 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
1955                 int service_mode, pkgmgr_client *pc, const char *pkg_type,
1956                 const char *pkgid, const char *custom_info,
1957                 pkgmgr_handler event_cb, void *data)
1958 {
1959         return pkgmgr_client_usr_request_service(service_type, service_mode,
1960                         pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
1961                         data);
1962 }
1963
1964 API int pkgmgr_client_usr_request_service(
1965                 pkgmgr_request_service_type service_type, int service_mode,
1966                 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
1967                 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
1968                 void *data)
1969 {
1970         int ret = 0;
1971
1972         /* Check for NULL value of service type */
1973         retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1974         retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1975
1976         switch (service_type) {
1977         case PM_REQUEST_MOVE:
1978                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1979                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1980                 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_EXTENDED), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1981
1982                 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1983                 break;
1984
1985         case PM_REQUEST_GET_SIZE:
1986                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1987                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1988                 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1989
1990                 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1991                 break;
1992
1993         case PM_REQUEST_KILL_APP:
1994         case PM_REQUEST_CHECK_APP:
1995                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1996                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1997
1998                 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1999                 if (ret < 0)
2000                         ERR("__check_app_process fail \n");
2001                 else
2002                         ret = PKGMGR_R_OK;
2003
2004                 break;
2005
2006         default:
2007                 ERR("Wrong Request\n");
2008                 ret = -1;
2009                 break;
2010         }
2011
2012 catch:
2013
2014         return ret;
2015 }
2016
2017 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
2018 {
2019         GVariant *result;
2020         int ret;
2021         struct pkgmgr_client_t *client;
2022
2023         if (pkgid == NULL || uid == GLOBAL_USER) {
2024                 ERR("invalid parameter");
2025                 return PKGMGR_R_EINVAL;
2026         }
2027
2028         client = pkgmgr_client_new(PC_REQUEST);
2029         if (client == NULL) {
2030                 ERR("out of memory");
2031                 return PKGMGR_R_ENOMEM;
2032         }
2033
2034         ret = pkgmgr_client_connection_send_request(client, "clearcache",
2035                         g_variant_new("(us)", uid, pkgid), &result);
2036         if (ret != PKGMGR_R_OK) {
2037                 ERR("request failed: %d", ret);
2038                 pkgmgr_client_free(client);
2039                 return ret;
2040         }
2041
2042         g_variant_get(result, "(i)", &ret);
2043         g_variant_unref(result);
2044         pkgmgr_client_free(client);
2045
2046         return ret;
2047 }
2048
2049 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
2050 {
2051         return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
2052 }
2053
2054 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
2055 {
2056         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
2057 }
2058
2059 API int pkgmgr_client_clear_all_cache_dir(void)
2060 {
2061         return pkgmgr_client_usr_clear_cache_dir(
2062                         PKG_CLEAR_ALL_CACHE, _getuid());
2063 }
2064
2065 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
2066                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
2067                 void *data)
2068 {
2069         return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
2070                         _getuid());
2071 }
2072
2073 /* TODO: deprecate(or remove) */
2074 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
2075                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
2076                 void *data, uid_t uid)
2077 {
2078         GVariant *result;
2079         int ret = PKGMGR_R_ECOMM;
2080         char *req_key = NULL;
2081         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2082         struct cb_info *cb_info;
2083
2084         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
2085                 ERR("invalid parameter");
2086                 return PKGMGR_R_EINVAL;
2087         }
2088
2089         if (client->pc_type != PC_REQUEST) {
2090                 ERR("client->pc_type is not PC_REQUEST");
2091                 return PKGMGR_R_EINVAL;
2092         }
2093
2094         /* FIXME */
2095         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
2096                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
2097         else
2098                 get_type = PM_GET_PKG_SIZE_INFO;
2099
2100         ret = pkgmgr_client_connection_send_request(client, "getsize",
2101                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
2102         if (ret != PKGMGR_R_OK) {
2103                 ERR("request failed: %d", ret);
2104                 return ret;
2105         }
2106
2107         g_variant_get(result, "(i&s)", &ret, &req_key);
2108         if (req_key == NULL) {
2109                 g_variant_unref(result);
2110                 return PKGMGR_R_ECOMM;
2111         }
2112         if (ret != PKGMGR_R_OK) {
2113                 g_variant_unref(result);
2114                 return ret;
2115         }
2116
2117         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
2118         if (cb_info == NULL) {
2119                 g_variant_unref(result);
2120                 return PKGMGR_R_ENOMEM;
2121         }
2122         g_variant_unref(result);
2123         ret = pkgmgr_client_connection_set_callback(client, cb_info);
2124         if (ret != PKGMGR_R_OK) {
2125                 __free_cb_info(cb_info);
2126                 return ret;
2127         }
2128         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2129
2130         return PKGMGR_R_OK;
2131 }
2132
2133 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
2134                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
2135                 void *user_data, uid_t uid)
2136 {
2137         GVariant *result;
2138         int ret = PKGMGR_R_ECOMM;
2139         char *req_key = NULL;
2140         int get_type;
2141         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2142         struct cb_info *cb_info;
2143
2144         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
2145                 ERR("invalid parameter");
2146                 return PKGMGR_R_EINVAL;
2147         }
2148
2149         if (client->pc_type != PC_REQUEST) {
2150                 ERR("client->pc_type is not PC_REQUEST");
2151                 return PKGMGR_R_EINVAL;
2152         }
2153
2154         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
2155                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
2156         else
2157                 get_type = PM_GET_PKG_SIZE_INFO;
2158
2159         ret = pkgmgr_client_connection_send_request(client, "getsize",
2160                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
2161         if (ret != PKGMGR_R_OK) {
2162                 ERR("request failed: %d", ret);
2163                 return ret;
2164         }
2165
2166         g_variant_get(result, "(i&s)", &ret, &req_key);
2167         if (req_key == NULL) {
2168                 g_variant_unref(result);
2169                 return PKGMGR_R_ECOMM;
2170         }
2171         if (ret != PKGMGR_R_OK) {
2172                 g_variant_unref(result);
2173                 return ret;
2174         }
2175
2176         cb_info = __create_size_info_cb_info(client, event_cb, user_data,
2177                         req_key);
2178         if (cb_info == NULL) {
2179                 g_variant_unref(result);
2180                 return PKGMGR_R_ENOMEM;
2181         }
2182         g_variant_unref(result);
2183         ret = pkgmgr_client_connection_set_callback(client, cb_info);
2184         if (ret != PKGMGR_R_OK) {
2185                 __free_cb_info(cb_info);
2186                 return ret;
2187         }
2188         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2189
2190         return PKGMGR_R_OK;
2191 }
2192
2193 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
2194                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
2195                 void *user_data)
2196 {
2197         return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
2198                         user_data, _getuid());
2199 }
2200
2201 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
2202                 pkgmgr_total_pkg_size_info_receive_cb event_cb,
2203                 void *user_data, uid_t uid)
2204 {       /* total package size info */
2205         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
2206                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
2207                         user_data, uid);
2208 }
2209
2210 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
2211                 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
2212 {
2213         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
2214                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
2215                         user_data, _getuid());
2216 }
2217
2218 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
2219                 const char *resp_data, char **req_data, char **license_url)
2220 {
2221         GVariant *result;
2222         int ret;
2223         char *data;
2224         char *url;
2225         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2226
2227         if (pc == NULL || resp_data == NULL || req_data == NULL ||
2228                         license_url == NULL) {
2229                 ERR("invalid parameter");
2230                 return PKGMGR_R_EINVAL;
2231         }
2232
2233         if (client->pc_type != PC_REQUEST) {
2234                 ERR("client->pc_type is not PC_REQUEST");
2235                 return PKGMGR_R_EINVAL;
2236         }
2237
2238         ret = pkgmgr_client_connection_send_request(client,
2239                         "generate_license_request",
2240                         g_variant_new("(s)", resp_data), &result);
2241         if (ret != PKGMGR_R_OK) {
2242                 ERR("request failed: %d", ret);
2243                 return ret;
2244         }
2245
2246         g_variant_get(result, "(i&s&s)", &ret, &data, &url);
2247         if (ret != PKGMGR_R_OK) {
2248                 ERR("generate_license_request failed: %d", ret);
2249                 g_variant_unref(result);
2250                 return ret;
2251         }
2252
2253         *req_data = strdup(data);
2254         *license_url = strdup(url);
2255
2256         g_variant_unref(result);
2257
2258         return PKGMGR_R_OK;
2259 }
2260
2261 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
2262 {
2263         GVariant *result;
2264         int ret;
2265         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2266
2267         if (pc == NULL || resp_data == NULL) {
2268                 ERR("invalid parameter");
2269                 return PKGMGR_R_EINVAL;
2270         }
2271
2272         if (client->pc_type != PC_REQUEST) {
2273                 ERR("client->pc_type is not PC_REQUEST");
2274                 return PKGMGR_R_EINVAL;
2275         }
2276
2277         ret = pkgmgr_client_connection_send_request(client, "register_license",
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)", &ret);
2285         g_variant_unref(result);
2286         if (ret != PKGMGR_R_OK)
2287                 ERR("register license failed: %d", ret);
2288
2289         return ret;
2290 }
2291
2292 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
2293                 const char *drm_file_path, const char *decrypted_file_path)
2294 {
2295         GVariant *result;
2296         int ret;
2297         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2298
2299         if (pc == NULL || drm_file_path == NULL ||
2300                         decrypted_file_path == NULL) {
2301                 ERR("invalid parameter");
2302                 return PKGMGR_R_EINVAL;
2303         }
2304
2305         if (client->pc_type != PC_REQUEST) {
2306                 ERR("client->pc_type is not PC_REQUEST");
2307                 return PKGMGR_R_EINVAL;
2308         }
2309
2310         ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
2311                         g_variant_new("(ss)", drm_file_path,
2312                                 decrypted_file_path), &result);
2313         if (ret != PKGMGR_R_OK) {
2314                 ERR("request failed: %d", ret);
2315                 return ret;
2316         }
2317
2318         g_variant_get(result, "(i)", &ret);
2319         g_variant_unref(result);
2320         if (ret != PKGMGR_R_OK)
2321                 ERR("decrypt_package failed: %d", ret);
2322
2323         return ret;
2324 }
2325
2326 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
2327 {
2328         return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
2329 }
2330
2331 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
2332                 const char *appid, uid_t uid)
2333 {
2334         int ret;
2335         GVariant *result;
2336         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2337
2338         if (pc == NULL || appid == NULL) {
2339                 ERR("Invalid parameter");
2340                 return PKGMGR_R_EINVAL;
2341         }
2342
2343         ret = pkgmgr_client_connection_send_request(client,
2344                         "enable_app_splash_screen",
2345                         g_variant_new("(us)", uid, appid), &result);
2346         if (ret != PKGMGR_R_OK) {
2347                 ERR("request failed: %d", ret);
2348                 return ret;
2349         }
2350
2351         g_variant_get(result, "(i)", &ret);
2352         g_variant_unref(result);
2353         if (ret != PKGMGR_R_OK)
2354                 ERR("enable splash screen failed: %d", ret);
2355
2356         return ret;
2357 }
2358
2359 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
2360                 const char *appid)
2361 {
2362         return pkgmgr_client_usr_disable_splash_screen(pc, appid,
2363                         _getuid());
2364 }
2365
2366 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
2367                 const char *appid, uid_t uid)
2368 {
2369         int ret;
2370         GVariant *result;
2371         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2372
2373         if (pc == NULL || appid == NULL) {
2374                 ERR("Invalid parameter");
2375                 return PKGMGR_R_EINVAL;
2376         }
2377
2378         ret = pkgmgr_client_connection_send_request(client,
2379                         "disable_app_splash_screen",
2380                         g_variant_new("(us)", uid, appid), &result);
2381         if (ret != PKGMGR_R_OK) {
2382                 ERR("request failed: %d", ret);
2383                 return ret;
2384         }
2385
2386         g_variant_get(result, "(i)", &ret);
2387         g_variant_unref(result);
2388         if (ret != PKGMGR_R_OK)
2389                 ERR("disable splash screen failed: %d", ret);
2390
2391         return ret;
2392 }
2393
2394 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2395                 int mode, uid_t uid)
2396 {
2397         GVariant *result;
2398         int ret = PKGMGR_R_ECOMM;
2399         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2400
2401         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2402                 ERR("invalid parameter");
2403                 return PKGMGR_R_EINVAL;
2404         }
2405
2406         ret = pkgmgr_client_connection_send_request(client,
2407                         "set_restriction_mode",
2408                         g_variant_new("(usi)", uid, pkgid, mode), &result);
2409         if (ret != PKGMGR_R_OK) {
2410                 ERR("request failed: %d", ret);
2411                 return ret;
2412         }
2413
2414         g_variant_get(result, "(i)", &ret);
2415         g_variant_unref(result);
2416
2417         return ret;
2418 }
2419
2420 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
2421                 const char *pkgid, int mode, uid_t uid)
2422 {
2423         return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
2424 }
2425
2426 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
2427                 const char *pkgid, int mode)
2428 {
2429         return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
2430                         _getuid());
2431 }
2432
2433 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2434                 int mode, uid_t uid)
2435 {
2436         GVariant *result;
2437         int ret = PKGMGR_R_ECOMM;
2438         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2439
2440         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2441                 ERR("invalid parameter");
2442                 return PKGMGR_R_EINVAL;
2443         }
2444
2445         ret = pkgmgr_client_connection_send_request(client,
2446                         "unset_restriction_mode",
2447                         g_variant_new("(usi)", uid, pkgid, mode), &result);
2448         if (ret != PKGMGR_R_OK) {
2449                 ERR("request failed: %d", ret);
2450                 return ret;
2451         }
2452
2453         g_variant_get(result, "(i)", &ret);
2454         g_variant_unref(result);
2455
2456         return ret;
2457
2458 }
2459
2460 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
2461                 const char *pkgid, int mode, uid_t uid)
2462 {
2463         return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
2464 }
2465
2466 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
2467                 const char *pkgid, int mode)
2468 {
2469         return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
2470                         _getuid());
2471 }
2472
2473 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2474                 int *mode, uid_t uid)
2475 {
2476         GVariant *result;
2477         int ret = PKGMGR_R_ECOMM;
2478         gint m;
2479         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2480
2481         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
2482                 ERR("invalid parameter");
2483                 return PKGMGR_R_EINVAL;
2484         }
2485
2486         ret = pkgmgr_client_connection_send_request(client,
2487                         "get_restriction_mode",
2488                         g_variant_new("(us)", uid, pkgid), &result);
2489         if (ret != PKGMGR_R_OK) {
2490                 ERR("request failed: %d", ret);
2491                 return ret;
2492         }
2493
2494         g_variant_get(result, "(ii)", &m, &ret);
2495         g_variant_unref(result);
2496         if (ret != PKGMGR_R_OK)
2497                 return ret;
2498
2499         *mode = m;
2500
2501         return PKGMGR_R_OK;
2502 }
2503
2504 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
2505                 const char *pkgid, int *mode, uid_t uid)
2506 {
2507         return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
2508 }
2509
2510 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
2511                 const char *pkgid, int *mode)
2512 {
2513         return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
2514                         _getuid());
2515 }
2516
2517 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
2518                 uid_t uid)
2519 {
2520         GVariant *result;
2521         int ret = PKGMGR_R_ECOMM;
2522         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2523
2524         if (pc == NULL) {
2525                 ERR("invalid parameter");
2526                 return PKGMGR_R_EINVAL;
2527         }
2528
2529         ret = pkgmgr_client_connection_send_request(client,
2530                         "set_restriction_mode",
2531                         g_variant_new("(usi)", uid, "", mode), &result);
2532         if (ret != PKGMGR_R_OK) {
2533                 ERR("request failed: %d", ret);
2534                 return ret;
2535         }
2536
2537         g_variant_get(result, "(i)", &ret);
2538         g_variant_unref(result);
2539
2540         return ret;
2541 }
2542
2543 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
2544 {
2545         return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
2546 }
2547
2548 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
2549                 uid_t uid)
2550 {
2551         GVariant *result;
2552         int ret = PKGMGR_R_ECOMM;
2553         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2554
2555         if (pc == NULL) {
2556                 ERR("invalid parameter");
2557                 return PKGMGR_R_EINVAL;
2558         }
2559
2560         ret = pkgmgr_client_connection_send_request(client,
2561                         "unset_restriction_mode",
2562                         g_variant_new("(usi)", uid, "", mode), &result);
2563         if (ret != PKGMGR_R_OK) {
2564                 ERR("request failed: %d", ret);
2565                 return ret;
2566         }
2567
2568         g_variant_get(result, "(i)", &ret);
2569         g_variant_unref(result);
2570
2571         return ret;
2572 }
2573
2574 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
2575 {
2576         return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
2577 }
2578
2579 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
2580                 int *mode, uid_t uid)
2581 {
2582         GVariant *result;
2583         int ret = PKGMGR_R_ECOMM;
2584         gint m;
2585         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2586
2587         if (pc == NULL) {
2588                 ERR("invalid parameter");
2589                 return PKGMGR_R_EINVAL;
2590         }
2591
2592         ret = pkgmgr_client_connection_send_request(client,
2593                         "get_restriction_mode",
2594                         g_variant_new("(us)", uid, ""), &result);
2595         if (ret != PKGMGR_R_OK) {
2596                 ERR("request failed: %d", ret);
2597                 return ret;
2598         }
2599
2600         g_variant_get(result, "(ii)", &m, &ret);
2601         g_variant_unref(result);
2602         if (ret != PKGMGR_R_OK)
2603                 return ret;
2604
2605         *mode = m;
2606
2607         return PKGMGR_R_OK;
2608 }
2609
2610 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
2611 {
2612         return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
2613 }
2614
2615 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
2616 {
2617         int ret;
2618         pkg_plugin_set *plugin_set;
2619         package_manager_pkg_detail_info_t *info;
2620         char *pkg_type;
2621
2622         if (pkg_path == NULL) {
2623                 ERR("invalid parameter");
2624                 return NULL;
2625         }
2626
2627         pkg_type = __get_type_from_path(pkg_path);
2628         if (pkg_type == NULL) {
2629                 ERR("cannot get pkg type");
2630                 return NULL;
2631         }
2632
2633         plugin_set = _package_manager_load_library(pkg_type);
2634         if (plugin_set == NULL) {
2635                 ERR("failed to load library for %s", pkg_type);
2636                 free(pkg_type);
2637                 return NULL;
2638         }
2639
2640         info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2641         if (info == NULL) {
2642                 ERR("out of memory");
2643                 free(pkg_type);
2644                 return NULL;
2645         }
2646
2647         ret = plugin_set->get_pkg_detail_info_from_package(pkg_path, info);
2648         if (ret) {
2649                 ERR("get_pkg_detail_info_from_package failed");
2650                 free(info);
2651                 free(pkg_type);
2652                 return NULL;
2653         }
2654
2655         free(pkg_type);
2656
2657         return (pkgmgr_info *)info;
2658 }
2659
2660 API int pkgmgr_client_free_pkginfo(pkgmgr_info *info)
2661 {
2662         package_manager_pkg_detail_info_t *pkg_info =
2663                 (package_manager_pkg_detail_info_t *)info;
2664
2665         if (info == NULL) {
2666                 ERR("invalid parameter");
2667                 return PKGMGR_R_EINVAL;
2668         }
2669
2670         g_list_free_full(pkg_info->privilege_list, free);
2671         free(pkg_info->icon_buf);
2672         free(pkg_info);
2673
2674         return PKGMGR_R_OK;
2675 }
2676
2677 API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid,
2678                 char *label, uid_t uid)
2679 {
2680         GVariant *result;
2681         int ret = -1;
2682         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2683
2684         if (pc == NULL || appid == NULL || label == NULL) {
2685                 ERR("Invalid parameter");
2686                 return PKGMGR_R_EINVAL;
2687         }
2688
2689         ret = pkgmgr_client_connection_send_request(client,
2690                         "set_app_label",
2691                         g_variant_new("(uss)", uid, appid, label), &result);
2692         if (ret != PKGMGR_R_OK) {
2693                 ERR("Request failed: %d", ret);
2694                 return ret;
2695         }
2696
2697         g_variant_get(result, "(i)", &ret);
2698         g_variant_unref(result);
2699
2700         return ret;
2701 }
2702
2703 API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label)
2704 {
2705         return pkgmgr_client_usr_set_app_label(pc, appid, label, _getuid());
2706 }
2707
2708 API int pkgmgr_client_usr_set_app_icon(pkgmgr_client *pc, char *appid,
2709                 char *icon_path, uid_t uid)
2710 {
2711         GVariant *result;
2712         int ret = -1;
2713         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2714
2715         if (pc == NULL || appid == NULL || icon_path == NULL) {
2716                 ERR("Invalid parameter");
2717                 return PKGMGR_R_EINVAL;
2718         }
2719
2720         if (access(icon_path, F_OK) != 0) {
2721                 ERR("failed to access: %s", icon_path);
2722                 return PKGMGR_R_EINVAL;
2723         }
2724
2725         ret = pkgmgr_client_connection_send_request(client,
2726                         "set_app_icon",
2727                         g_variant_new("(uss)", uid, appid, icon_path), &result);
2728         if (ret != PKGMGR_R_OK) {
2729                 ERR("Request failed: %d", ret);
2730                 return ret;
2731         }
2732
2733         g_variant_get(result, "(i)", &ret);
2734         g_variant_unref(result);
2735
2736         return ret;
2737 }
2738
2739 API int pkgmgr_client_set_app_icon(pkgmgr_client *pc, char *appid, char *icon_path)
2740 {
2741         return pkgmgr_client_usr_set_app_icon(pc, appid, icon_path, _getuid());
2742 }
2743
2744 API int pkgmgr_client_set_debug_mode(pkgmgr_client *pc, bool debug_mode)
2745 {
2746         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2747
2748         if (pc == NULL) {
2749                 ERR("invalid parameter");
2750                 return PKGMGR_R_EINVAL;
2751         }
2752
2753         client->debug_mode = debug_mode;
2754
2755         return PKGMGR_R_OK;
2756 }
2757
2758 API int pkgmgr_client_set_skip_optimization(pkgmgr_client *pc, bool skip_optimization)
2759 {
2760         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2761
2762         if (pc == NULL) {
2763                 ERR("invalid parameter");
2764                 return PKGMGR_R_EINVAL;
2765         }
2766
2767         client->skip_optimization = skip_optimization;
2768
2769         return PKGMGR_R_OK;
2770 }
2771
2772 API int pkgmgr_client_usr_migrate_external_image(pkgmgr_client *pc,
2773                 const char *pkgid, uid_t uid)
2774 {
2775         GVariant *result;
2776         int ret = PKGMGR_R_ECOMM;
2777         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2778
2779         if (pc == NULL) {
2780                 ERR("invalid parameter");
2781                 return PKGMGR_R_EINVAL;
2782         }
2783
2784         ret = pkgmgr_client_connection_send_request(client,
2785                         "migrate_external_image",
2786                         g_variant_new("(us)", uid, pkgid), &result);
2787         if (ret != PKGMGR_R_OK) {
2788                 ERR("request failed: %d", ret);
2789                 return ret;
2790         }
2791
2792         g_variant_get(result, "(i)", &ret);
2793         g_variant_unref(result);
2794
2795         return ret;
2796 }
2797
2798 API int pkgmgr_client_add_res_copy_path(pkgmgr_client *pc,
2799                 const char *src_path, const char *dest_path)
2800 {
2801         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2802
2803         if (pc == NULL || src_path == NULL) {
2804                 ERR("invalid parameter");
2805                 return PKGMGR_R_EINVAL;
2806         }
2807
2808         if (client->res_copy_builder == NULL) {
2809                 client->res_copy_builder =
2810                                 g_variant_builder_new(G_VARIANT_TYPE("a(ss)"));
2811                 if (client->res_copy_builder == NULL) {
2812                         ERR("out of memory");
2813                         return PKGMGR_R_ENOMEM;
2814                 }
2815         }
2816
2817         g_variant_builder_add(client->res_copy_builder, "(ss)",
2818                         src_path, dest_path ? dest_path : "");
2819
2820         return PKGMGR_R_OK;
2821 }
2822
2823 API int pkgmgr_client_res_copy(pkgmgr_client *pc,
2824                 pkgmgr_res_copy_handler event_cb, void *user_data)
2825 {
2826         GVariant *result;
2827         int ret;
2828         char *req_key = NULL;
2829         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2830         struct cb_info *cb_info;
2831
2832         if (pc == NULL || event_cb == NULL) {
2833                 ERR("invalid parameter");
2834                 return PKGMGR_R_EINVAL;
2835         }
2836
2837         ret = pkgmgr_client_connection_send_request(client,
2838                         "res_copy",
2839                         g_variant_new("(a(ss))",
2840                         client->res_copy_builder), &result);
2841         if (ret != PKGMGR_R_OK) {
2842                 ERR("request failed: %d", ret);
2843                 return ret;
2844         }
2845
2846         g_variant_get(result, "(i&s)", &ret, &req_key);
2847         if (req_key == NULL) {
2848                 g_variant_unref(result);
2849                 return PKGMGR_R_ECOMM;
2850         }
2851         if (ret != PKGMGR_R_OK) {
2852                 g_variant_unref(result);
2853                 return ret;
2854         }
2855
2856         cb_info = __create_res_copy_event_cb_info(client,
2857                         event_cb, user_data, req_key);
2858         g_variant_unref(result);
2859         if (cb_info == NULL)
2860                 return PKGMGR_R_ENOMEM;
2861
2862         ret = pkgmgr_client_connection_set_callback(client, cb_info);
2863         if (ret != PKGMGR_R_OK) {
2864                 __free_cb_info(cb_info);
2865                 return ret;
2866         }
2867         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2868
2869         return cb_info->req_id;
2870 }
2871
2872 API int pkgmgr_client_add_res_create_dir_path(pkgmgr_client *pc,
2873                 const char *dir_path)
2874 {
2875         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2876
2877         if (pc == NULL || dir_path == NULL) {
2878                 ERR("invalid parameter");
2879                 return PKGMGR_R_EINVAL;
2880         }
2881
2882         if (client->res_create_dir_builder == NULL) {
2883                 client->res_create_dir_builder =
2884                                 g_variant_builder_new(G_VARIANT_TYPE("as"));
2885                 if (client->res_create_dir_builder == NULL) {
2886                         ERR("out of memory");
2887                         return PKGMGR_R_ENOMEM;
2888                 }
2889         }
2890
2891         g_variant_builder_add(client->res_create_dir_builder, "s", dir_path);
2892
2893         return PKGMGR_R_OK;
2894 }
2895
2896 API int pkgmgr_client_res_create_dir(pkgmgr_client *pc,
2897                 pkgmgr_res_copy_handler event_cb, void *user_data)
2898 {
2899         GVariant *result;
2900         int ret;
2901         char *req_key = NULL;
2902         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2903         struct cb_info *cb_info;
2904
2905         if (pc == NULL || event_cb == NULL) {
2906                 ERR("invalid parameter");
2907                 return PKGMGR_R_EINVAL;
2908         }
2909
2910         ret = pkgmgr_client_connection_send_request(client,
2911                         "res_create_dir",
2912                         g_variant_new("(as)",
2913                         client->res_create_dir_builder), &result);
2914         if (ret != PKGMGR_R_OK) {
2915                 ERR("request failed: %d", ret);
2916                 return ret;
2917         }
2918
2919         g_variant_get(result, "(i&s)", &ret, &req_key);
2920         if (req_key == NULL) {
2921                 g_variant_unref(result);
2922                 return PKGMGR_R_ECOMM;
2923         }
2924         if (ret != PKGMGR_R_OK) {
2925                 g_variant_unref(result);
2926                 return ret;
2927         }
2928
2929         cb_info = __create_res_copy_event_cb_info(client,
2930                         event_cb, user_data, req_key);
2931         g_variant_unref(result);
2932         if (cb_info == NULL)
2933                 return PKGMGR_R_ENOMEM;
2934
2935         ret = pkgmgr_client_connection_set_callback(client, cb_info);
2936         if (ret != PKGMGR_R_OK) {
2937                 __free_cb_info(cb_info);
2938                 return ret;
2939         }
2940         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2941
2942         return cb_info->req_id;
2943 }
2944
2945 API int pkgmgr_client_add_res_remove_path(pkgmgr_client *pc,
2946                 const char *res_path)
2947 {
2948         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2949
2950         if (pc == NULL || res_path == NULL) {
2951                 ERR("invalid parameter");
2952                 return PKGMGR_R_EINVAL;
2953         }
2954
2955         if (client->res_remove_builder == NULL) {
2956                 client->res_remove_builder =
2957                                 g_variant_builder_new(G_VARIANT_TYPE("as"));
2958                 if (client->res_remove_builder == NULL) {
2959                         ERR("out of memory");
2960                         return PKGMGR_R_ENOMEM;
2961                 }
2962         }
2963
2964         g_variant_builder_add(client->res_remove_builder, "s", res_path);
2965
2966         return PKGMGR_R_OK;
2967 }
2968
2969 API int pkgmgr_client_res_remove(pkgmgr_client *pc,
2970                 pkgmgr_res_copy_handler event_cb, void *user_data)
2971 {
2972         GVariant *result;
2973         int ret;
2974         char *req_key = NULL;
2975         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2976         struct cb_info *cb_info;
2977
2978         if (pc == NULL || event_cb == NULL) {
2979                 ERR("invalid parameter");
2980                 return PKGMGR_R_EINVAL;
2981         }
2982
2983         ret = pkgmgr_client_connection_send_request(client,
2984                         "res_remove",
2985                         g_variant_new("(as)",
2986                         client->res_remove_builder), &result);
2987         if (ret != PKGMGR_R_OK) {
2988                 ERR("request failed: %d", ret);
2989                 return ret;
2990         }
2991
2992         g_variant_get(result, "(i&s)", &ret, &req_key);
2993         if (req_key == NULL) {
2994                 g_variant_unref(result);
2995                 return PKGMGR_R_ECOMM;
2996         }
2997         if (ret != PKGMGR_R_OK) {
2998                 g_variant_unref(result);
2999                 return ret;
3000         }
3001
3002         cb_info = __create_res_copy_event_cb_info(client,
3003                         event_cb, user_data, req_key);
3004         g_variant_unref(result);
3005         if (cb_info == NULL)
3006                 return PKGMGR_R_ENOMEM;
3007
3008         ret = pkgmgr_client_connection_set_callback(client, cb_info);
3009         if (ret != PKGMGR_R_OK) {
3010                 __free_cb_info(cb_info);
3011                 return ret;
3012         }
3013         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
3014
3015         return cb_info->req_id;
3016 }
3017
3018 API int pkgmgr_client_res_uninstall(pkgmgr_client *pc, const char *pkgid)
3019 {
3020         return pkgmgr_client_res_usr_uninstall(pc, pkgid, _getuid());
3021 }
3022
3023 API int pkgmgr_client_res_usr_uninstall(pkgmgr_client *pc, const char *pkgid,
3024                 uid_t uid)
3025 {
3026         GVariant *result;
3027         int ret = PKGMGR_R_ECOMM;
3028         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
3029
3030         if (pc == NULL || pkgid == NULL) {
3031                 ERR("invalid parameter");
3032                 return PKGMGR_R_EINVAL;
3033         }
3034
3035         ret = pkgmgr_client_connection_send_request(client,
3036                         "res_uninstall",
3037                         g_variant_new("(us)", uid, pkgid), &result);
3038         if (ret != PKGMGR_R_OK) {
3039                 ERR("request failed: %d", ret);
3040                 return ret;
3041         }
3042
3043         g_variant_get(result, "(i)", &ret);
3044         g_variant_unref(result);
3045
3046         return ret;
3047 }
3048
3049 API pkgmgr_res_event_info *pkgmgr_res_event_info_new()
3050 {
3051         pkgmgr_res_event_info_t *info;
3052
3053         info = calloc(1, sizeof(pkgmgr_res_event_info_t));
3054         if (info == NULL) {
3055                 ERR("out of memory");
3056                 return NULL;
3057         }
3058
3059         return (pkgmgr_res_event_info *)info;
3060 }
3061
3062 API int pkgmgr_res_event_info_free(pkgmgr_res_event_info *info)
3063 {
3064         pkgmgr_res_event_info_t *event_info =
3065                         (pkgmgr_res_event_info_t *)info;
3066
3067         if (event_info == NULL) {
3068                 ERR("invalid argument");
3069                 return PKGMGR_R_EINVAL;
3070         }
3071
3072         free(event_info);
3073
3074         return PKGMGR_R_OK;
3075 }
3076
3077 API int pkgmgr_res_event_info_set_error_code(pkgmgr_res_event_info *handle, int error_code)
3078 {
3079         pkgmgr_res_event_info_t *info = handle;
3080         if (info == NULL) {
3081                 ERR("invalid parameter");
3082                 return PKGMGR_R_EINVAL;
3083         }
3084
3085         info->error_code = error_code;
3086         return PKGMGR_R_OK;
3087 }
3088
3089 API int pkgmgr_res_event_info_get_error_code(pkgmgr_res_event_info *handle, int *error_code)
3090 {
3091         pkgmgr_res_event_info_t *info = handle;
3092         if (info == NULL || error_code == NULL) {
3093                 ERR("invalid parameter");
3094                 return PKGMGR_R_EINVAL;
3095         }
3096
3097         *error_code = info->error_code;
3098         return PKGMGR_R_OK;
3099 }