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