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
  33 #include <glib.h>
  34
  35 #include <pkgmgr-info.h>
  36 #include <iniparser.h>
  37 /* For multi-user support */
  38 #include <tzplatform_config.h>
  39
  40 #include "package-manager.h"
  41 #include "pkgmgr_client_debug.h"
  42 #include "pkgmgr_client_internal.h"
  43
  44 /* API export macro */
  45 #ifndef API
  46 #define API __attribute__ ((visibility("default")))
  47 #endif
  48
  49 #define PKG_TMP_PATH tzplatform_mkpath(TZ_USER_APP, "tmp")
  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 inline uid_t _getuid(void)
  58 {
  59         uid_t uid = getuid();
  60
  61         if (uid < REGULAR_USER)
  62                 return GLOBAL_USER;
  63         else
  64                 return uid;
  65 }
  66
  67 static int _get_request_id()
  68 {
  69         static int internal_req_id = 1;
  70
  71         return internal_req_id++;
  72 }
  73
  74 static struct cb_info *__create_event_cb_info(struct pkgmgr_client_t *client,
  75                 pkgmgr_handler event_cb, void *data, const char *req_key)
  76 {
  77         struct cb_info *cb_info;
  78
  79         cb_info = calloc(1, sizeof(struct cb_info));
  80         if (cb_info == NULL) {
  81                 ERR("out of memory");
  82                 return NULL;
  83         }
  84         cb_info->client = client;
  85         cb_info->event_cb = event_cb;
  86         cb_info->data = data;
  87         cb_info->req_id = _get_request_id();
  88         if (req_key != NULL) {
  89                 cb_info->req_key = strdup(req_key);
  90                 if (cb_info->req_key == NULL) {
  91                         ERR("out of memory");
  92                         free(cb_info);
  93                         return NULL;
  94                 }
  95         }
  96
  97         return cb_info;
  98 }
  99
 100 static struct cb_info *__create_app_event_cb_info(
 101                 struct pkgmgr_client_t *client, pkgmgr_app_handler app_event_cb,
 102                 void *data, const char *req_key)
 103 {
 104         struct cb_info *cb_info;
 105
 106         cb_info = calloc(1, sizeof(struct cb_info));
 107         if (cb_info == NULL) {
 108                 ERR("out of memory");
 109                 return NULL;
 110         }
 111         cb_info->client = client;
 112         cb_info->app_event_cb = app_event_cb;
 113         cb_info->data = data;
 114         cb_info->req_id = _get_request_id();
 115         if (req_key != NULL) {
 116                 cb_info->req_key = strdup(req_key);
 117                 if (cb_info->req_key == NULL) {
 118                         ERR("out of memory");
 119                         free(cb_info);
 120                         return NULL;
 121                 }
 122         }
 123
 124         return cb_info;
 125 }
 126
 127 static struct cb_info *__create_size_info_cb_info(
 128                 struct pkgmgr_client_t *client,
 129                 pkgmgr_pkg_size_info_receive_cb size_info_cb,
 130                 void *data, const char *req_key)
 131 {
 132         struct cb_info *cb_info;
 133
 134         cb_info = calloc(1, sizeof(struct cb_info));
 135         if (cb_info == NULL) {
 136                 ERR("out of memory");
 137                 return NULL;
 138         }
 139         cb_info->client = client;
 140         cb_info->size_info_cb = size_info_cb;
 141         cb_info->data = data;
 142         cb_info->req_id = _get_request_id();
 143         if (req_key != NULL) {
 144                 cb_info->req_key = strdup(req_key);
 145                 if (cb_info->req_key == NULL) {
 146                         ERR("out of memory");
 147                         free(cb_info);
 148                         return NULL;
 149                 }
 150         }
 151
 152         return cb_info;
 153 }
 154
 155 static void __free_cb_info(struct cb_info *cb_info)
 156 {
 157         free(cb_info->req_key);
 158         free(cb_info);
 159 }
 160
 161 static int __sync_process(const char *req_key)
 162 {
 163         int ret;
 164         char info_file[PKG_STRING_LEN_MAX] = {'\0', };
 165         int result = -1;
 166         int check_cnt = 0;
 167         FILE *fp;
 168         char buf[PKG_STRING_LEN_MAX] = {0, };
 169
 170         snprintf(info_file, PKG_STRING_LEN_MAX, "%s/%s", PKG_SIZE_INFO_PATH, req_key);
 171         while (1) {
 172                 check_cnt++;
 173
 174                 if (access(info_file, F_OK) == 0) {
 175                         fp = fopen(info_file, "r");
 176                         if (fp == NULL) {
 177                                 DBG("file is not generated yet.... wait\n");
 178                                 usleep(100 * 1000);     /* 100ms sleep*/
 179                                 continue;
 180                         }
 181
 182                         if (fgets(buf, PKG_STRING_LEN_MAX, fp) == NULL) {
 183                                 ERR("failed to read info file");
 184                                 fclose(fp);
 185                                 break;
 186                         }
 187                         fclose(fp);
 188
 189                         DBG("info_file file is generated, result = %s. \n", buf);
 190                         result = atoi(buf);
 191                         break;
 192                 }
 193
 194                 DBG("file is not generated yet.... wait\n");
 195                 usleep(100 * 1000);     /* 100ms sleep*/
 196
 197                 if (check_cnt > 6000) { /* 60s * 10 time over*/
 198                         ERR("wait time over!!\n");
 199                         break;
 200                 }
 201         }
 202
 203         ret = remove(info_file);
 204         if (ret < 0)
 205                 ERR("file is can not remove[%s, %d]\n", info_file, ret);
 206
 207         return result;
 208 }
 209
 210 static int __get_size_process(pkgmgr_client *pc, const char *pkgid, uid_t uid,
 211                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
 212                 void *data)
 213 {
 214         GVariant *result;
 215         int ret = PKGMGR_R_ECOMM;
 216         char *req_key = NULL;
 217         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 218
 219         if (pc == NULL || pkgid == NULL) {
 220                 ERR("invalid parameter");
 221                 return PKGMGR_R_EINVAL;
 222         }
 223
 224         if (client->pc_type != PC_REQUEST) {
 225                 ERR("client->pc_type is not PC_REQUEST");
 226                 return PKGMGR_R_EINVAL;
 227         }
 228
 229         ret = pkgmgr_client_connection_send_request(client, "getsize",
 230                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
 231         if (ret != PKGMGR_R_OK) {
 232                 ERR("request failed: %d", ret);
 233                 return ret;
 234         }
 235
 236         g_variant_get(result, "(i&s)", &ret, &req_key);
 237         if (req_key == NULL) {
 238                 g_variant_unref(result);
 239                 return PKGMGR_R_ECOMM;
 240         }
 241         if (ret != PKGMGR_R_OK) {
 242                 g_variant_unref(result);
 243                 return ret;
 244         }
 245
 246         ret = __sync_process(req_key);
 247         if (ret < 0)
 248                 ERR("get size failed, ret=%d\n", ret);
 249
 250         g_variant_unref(result);
 251
 252         return ret;
 253 }
 254
 255 static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid,
 256                 const char *pkg_type, uid_t uid, pkgmgr_move_type move_type,
 257                 pkgmgr_handler event_cb, void *data)
 258 {
 259         int ret;
 260
 261         ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, event_cb, data, uid);
 262         if (ret < 0) {
 263                 ERR("move request failed");
 264                 return ret;
 265         }
 266
 267         return ret;
 268 }
 269
 270 static int __check_app_process(pkgmgr_request_service_type service_type,
 271                 pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data)
 272 {
 273         GVariant *result;
 274         int ret = PKGMGR_R_ECOMM;
 275         pkgmgrinfo_pkginfo_h handle;
 276         int pid = -1;
 277         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 278
 279         retvm_if(client->pc_type != PC_REQUEST, PKGMGR_R_EINVAL, "client->pc_type is not PC_REQUEST\n");
 280
 281         if (uid != GLOBAL_USER)
 282                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
 283         else
 284                 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 285         retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_pkginfo failed");
 286
 287         if (service_type == PM_REQUEST_KILL_APP)
 288                 ret = pkgmgr_client_connection_send_request(client, "kill",
 289                                 g_variant_new("(us)", uid, pkgid), &result);
 290         else if (service_type == PM_REQUEST_CHECK_APP)
 291                 ret = pkgmgr_client_connection_send_request(client, "check",
 292                                 g_variant_new("(us)", uid, pkgid), &result);
 293         if (ret != PKGMGR_R_OK) {
 294                 ERR("request failed: %d", ret);
 295                 return ret;
 296         }
 297
 298         g_variant_get(result, "(ii)", &ret, &pid);
 299         g_variant_unref(result);
 300         if (ret != PKGMGR_R_OK) {
 301                 ERR("request failed, ret=%d", ret);
 302                 return ret;
 303         }
 304
 305         *(int *)data = pid;
 306
 307         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 308
 309         return ret;
 310
 311 }
 312
 313 static int __request_size_info(pkgmgr_client *pc, uid_t uid)
 314 {
 315         GVariant *result;
 316         int ret = PKGMGR_R_ECOMM;
 317 //      char *req_key = NULL;
 318         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 319
 320         if (pc == NULL) {
 321                 ERR("invalid parameter");
 322                 return PKGMGR_R_EINVAL;
 323         }
 324
 325         if (client->pc_type != PC_REQUEST) {
 326                 ERR("client->pc_type is not PC_REQUEST");
 327                 return PKGMGR_R_EINVAL;
 328         }
 329
 330         ret = pkgmgr_client_connection_send_request(client, "getsize",
 331                         g_variant_new("(usi)", uid, "size_info",
 332                                 PM_GET_SIZE_INFO), &result);
 333         if (ret != PKGMGR_R_OK) {
 334                 ERR("request failed: %d", ret);
 335                 return ret;
 336         }
 337
 338 /*
 339         g_variant_get(result, "(i&s)", &ret, &req_key);
 340         if (req_key == NULL) {
 341                 g_variant_unref(result);
 342                 return PKGMGR_R_ECOMM;
 343         }
 344 */
 345
 346         g_variant_unref(result);
 347
 348         return ret;
 349 }
 350
 351 API pkgmgr_client *pkgmgr_client_new(pkgmgr_client_type pc_type)
 352 {
 353         struct pkgmgr_client_t *client;
 354
 355         if (pc_type == PC_BROADCAST) {
 356                 ERR("broadcast type is not supported");
 357                 return NULL;
 358         }
 359
 360         if (pc_type != PC_REQUEST && pc_type != PC_LISTENING) {
 361                 ERR("invalid parameter");
 362                 return NULL;
 363         }
 364
 365         client = calloc(1, sizeof(struct pkgmgr_client_t));
 366         if (client == NULL) {
 367                 ERR("out of memory");
 368                 return NULL;
 369         }
 370
 371         client->pc_type = pc_type;
 372         client->status_type = PKGMGR_CLIENT_STATUS_ALL;
 373
 374         if (pkgmgr_client_connection_connect(client))
 375                 return NULL;
 376
 377         return (pkgmgr_client *)client;
 378 }
 379
 380 API int pkgmgr_client_free(pkgmgr_client *pc)
 381 {
 382         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 383
 384         if (pc == NULL) {
 385                 ERR("invalid argument");
 386                 return PKGMGR_R_EINVAL;
 387         }
 388
 389         pkgmgr_client_remove_listen_status(client);
 390         pkgmgr_client_connection_disconnect(client);
 391         if (client->tep_path)
 392                 free(client->tep_path);
 393         free(client);
 394
 395         return PKGMGR_R_OK;
 396 }
 397
 398 static char *__get_type_from_path(const char *pkg_path)
 399 {
 400         int ret;
 401         char mimetype[255] = { '\0', };
 402         char extlist[256] = { '\0', };
 403         char *pkg_type;
 404
 405         ret = _get_mime_from_file(pkg_path, mimetype, sizeof(mimetype));
 406         if (ret) {
 407                 ERR("_get_mime_from_file() failed - error code[%d]\n", ret);
 408                 return NULL;
 409         }
 410
 411         ret = _get_mime_extension(mimetype, extlist, sizeof(extlist));
 412         if (ret) {
 413                 ERR("_get_mime_extension() failed - error code[%d]\n", ret);
 414                 return NULL;
 415         }
 416
 417         if (strlen(extlist) == 0)
 418                 return NULL;
 419
 420         if (strchr(extlist, ','))
 421                 extlist[strlen(extlist) - strlen(strchr(extlist, ','))] = '\0';
 422
 423         pkg_type = strchr(extlist, '.') + 1;
 424         return strdup(pkg_type);
 425 }
 426
 427 API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, const char *tep_path,
 428                 bool tep_move)
 429 {
 430         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *) pc;
 431
 432         if (pc == NULL || tep_path == NULL) {
 433                 ERR("invalied parameter");
 434                 return PKGMGR_R_EINVAL;
 435         }
 436
 437         if (client->tep_path)
 438                 free(client->tep_path);
 439
 440         client->tep_path = strdup(tep_path);
 441         client->tep_move = tep_move;
 442
 443         return PKGMGR_R_OK;
 444 }
 445
 446 API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
 447                 const char *descriptor_path, const char *pkg_path,
 448                 const char *optional_data, pkgmgr_mode mode,
 449                 pkgmgr_handler event_cb, void *data, uid_t uid)
 450 {
 451         GVariant *result;
 452         int ret = PKGMGR_R_ECOMM;
 453         char *req_key = NULL;
 454         GVariantBuilder *builder = NULL;
 455         GVariant *args = NULL;
 456         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 457         char *pkgtype;
 458         struct cb_info *cb_info;
 459
 460         if (pc == NULL || pkg_path == NULL) {
 461                 ERR("invalid parameter");
 462                 return PKGMGR_R_EINVAL;
 463         }
 464
 465         if (client->pc_type != PC_REQUEST) {
 466                 ERR("client type is not PC_REQUEST");
 467                 return PKGMGR_R_EINVAL;
 468         }
 469
 470         if (access(pkg_path, F_OK) != 0) {
 471                 ERR("failed to access: %s", pkg_path);
 472                 return PKGMGR_R_EINVAL;
 473         }
 474
 475         if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
 476                 ERR("failed to access: %s", client->tep_path);
 477                 return PKGMGR_R_EINVAL;
 478         }
 479
 480         /* TODO: check pkg's type on server-side */
 481         if (pkg_type == NULL)
 482                 pkgtype = __get_type_from_path(pkg_path);
 483         else
 484                 pkgtype = strdup(pkg_type);
 485
 486         /* build arguments */
 487         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 488         if (client->tep_path) {
 489                 g_variant_builder_add(builder, "s", "-e");
 490                 g_variant_builder_add(builder, "s", client->tep_path);
 491                 g_variant_builder_add(builder, "s", "-M");
 492                 /* TODO: revise tep_move */
 493                 g_variant_builder_add(builder, "s",
 494                                 client->tep_move ? "tep_move" : "tep_copy");
 495         }
 496
 497         args = g_variant_new("as", builder);
 498         g_variant_builder_unref(builder);
 499
 500         ret = pkgmgr_client_connection_send_request(client, "install",
 501                         g_variant_new("(uss@as)", uid, pkgtype, pkg_path, args),
 502                         &result);
 503         if (ret != PKGMGR_R_OK) {
 504                 ERR("request failed: %d", ret);
 505                 return ret;
 506         }
 507
 508         g_variant_get(result, "(i&s)", &ret, &req_key);
 509         if (req_key == NULL) {
 510                 g_variant_unref(result);
 511                 return PKGMGR_R_ECOMM;
 512         }
 513         if (ret != PKGMGR_R_OK) {
 514                 g_variant_unref(result);
 515                 return ret;
 516         }
 517
 518         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
 519         if (cb_info == NULL) {
 520                 g_variant_unref(result);
 521                 return PKGMGR_R_ENOMEM;
 522         }
 523         g_variant_unref(result);
 524         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 525         if (ret != PKGMGR_R_OK) {
 526                 __free_cb_info(cb_info);
 527                 return ret;
 528         }
 529         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 530
 531         return cb_info->req_id;
 532 }
 533
 534 API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
 535                 const char *descriptor_path, const char *pkg_path,
 536                 const char *optional_data, pkgmgr_mode mode,
 537                 pkgmgr_handler event_cb, void *data)
 538 {
 539         return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path,
 540                         pkg_path, optional_data, mode, event_cb, data,
 541                         _getuid());
 542 }
 543
 544 API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
 545                 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
 546                 pkgmgr_handler event_cb, void *data)
 547 {
 548         return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_data,
 549                         mode, event_cb, data, _getuid());
 550 }
 551
 552 API int pkgmgr_client_usr_reinstall(pkgmgr_client *pc, const char *pkg_type,
 553                 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
 554                 pkgmgr_handler event_cb, void *data, uid_t uid)
 555 {
 556         GVariant *result;
 557         int ret = PKGMGR_R_ECOMM;
 558         char *req_key = NULL;
 559         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 560         char *pkgtype;
 561         pkgmgrinfo_pkginfo_h handle;
 562         struct cb_info *cb_info;
 563
 564         if (pc == NULL || pkgid == NULL) {
 565                 ERR("invalid parameter");
 566                 return PKGMGR_R_EINVAL;
 567         }
 568
 569         if (client->pc_type != PC_REQUEST) {
 570                 ERR("client->pc_type is not PC_REQUEST");
 571                 return PKGMGR_R_EINVAL;
 572         }
 573
 574         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
 575         if (ret < 0)
 576                 return PKGMGR_R_EINVAL;
 577
 578         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
 579         if (ret < 0) {
 580                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 581                 return PKGMGR_R_ERROR;
 582         }
 583
 584         ret = pkgmgr_client_connection_send_request(client, "reinstall",
 585                         g_variant_new("(uss)", uid, pkgtype, pkgid), &result);
 586         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 587         if (ret != PKGMGR_R_OK) {
 588                 ERR("request failed: %d", ret);
 589                 return ret;
 590         }
 591
 592         g_variant_get(result, "(i&s)", &ret, &req_key);
 593         if (req_key == NULL) {
 594                 g_variant_unref(result);
 595                 return PKGMGR_R_ECOMM;
 596         }
 597         if (ret != PKGMGR_R_OK) {
 598                 g_variant_unref(result);
 599                 return ret;
 600         }
 601
 602         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
 603         if (cb_info == NULL) {
 604                 g_variant_unref(result);
 605                 return PKGMGR_R_ENOMEM;
 606         }
 607         g_variant_unref(result);
 608         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 609         if (ret != PKGMGR_R_OK) {
 610                 __free_cb_info(cb_info);
 611                 return ret;
 612         }
 613         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 614
 615         return cb_info->req_id;
 616 }
 617
 618 API int pkgmgr_client_usr_mount_install(pkgmgr_client *pc, const char *pkg_type,
 619                 const char *descriptor_path, const char *pkg_path,
 620                 const char *optional_data, pkgmgr_mode mode,
 621                 pkgmgr_handler event_cb, void *data, uid_t uid)
 622 {
 623         GVariant *result;
 624         int ret = PKGMGR_R_ECOMM;
 625         char *req_key = NULL;
 626         GVariantBuilder *builder = NULL;
 627         GVariant *args = NULL;
 628         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 629         char *pkgtype;
 630         struct cb_info *cb_info;
 631
 632         if (pc == NULL || pkg_path == NULL) {
 633                 ERR("invalid parameter");
 634                 return PKGMGR_R_EINVAL;
 635         }
 636
 637         if (client->pc_type != PC_REQUEST) {
 638                 ERR("client->pc_type is not PC_REQUEST");
 639                 return PKGMGR_R_EINVAL;
 640         }
 641
 642         if (access(pkg_path, F_OK) != 0) {
 643                 ERR("failed to access: %s", pkg_path);
 644                 return PKGMGR_R_EINVAL;
 645         }
 646
 647         if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
 648                 ERR("failed to access: %s", client->tep_path);
 649                 return PKGMGR_R_EINVAL;
 650         }
 651
 652         /* TODO: check pkg's type on server-side */
 653         if (pkg_type == NULL)
 654                 pkgtype = __get_type_from_path(pkg_path);
 655         else
 656                 pkgtype = strdup(pkg_type);
 657
 658         /* build arguments */
 659         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 660         if (client->tep_path) {
 661                 g_variant_builder_add(builder, "s", "-e");
 662                 g_variant_builder_add(builder, "s", client->tep_path);
 663                 g_variant_builder_add(builder, "s", "-M");
 664                 /* TODO: revise tep_move */
 665                 g_variant_builder_add(builder, "s",
 666                                 client->tep_move ? "tep_move" : "tep_copy");
 667         }
 668
 669         args = g_variant_new("as", builder);
 670         g_variant_builder_unref(builder);
 671
 672         ret = pkgmgr_client_connection_send_request(client, "mount_install",
 673                         g_variant_new("(uss@as)", uid, pkgtype, pkg_path, args),
 674                         &result);
 675         if (ret != PKGMGR_R_OK) {
 676                 ERR("request failed: %d", ret);
 677                 return ret;
 678         }
 679
 680         g_variant_get(result, "(i&s)", &ret, &req_key);
 681         if (req_key == NULL) {
 682                 g_variant_unref(result);
 683                 return PKGMGR_R_ECOMM;
 684         }
 685         if (ret != PKGMGR_R_OK) {
 686                 g_variant_unref(result);
 687                 return ret;
 688         }
 689
 690         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
 691         if (cb_info == NULL) {
 692                 g_variant_unref(result);
 693                 return PKGMGR_R_ENOMEM;
 694         }
 695         g_variant_unref(result);
 696         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 697         if (ret != PKGMGR_R_OK) {
 698                 __free_cb_info(cb_info);
 699                 return ret;
 700         }
 701         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 702
 703         return cb_info->req_id;
 704 }
 705
 706 API int pkgmgr_client_mount_install(pkgmgr_client *pc, const char *pkg_type,
 707                 const char *descriptor_path, const char *pkg_path,
 708                 const char *optional_data, pkgmgr_mode mode,
 709                 pkgmgr_handler event_cb, void *data)
 710 {
 711         return pkgmgr_client_usr_mount_install(pc, pkg_type, descriptor_path,
 712                         pkg_path, optional_data, mode, event_cb, data,
 713                         _getuid());
 714 }
 715
 716 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
 717                 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
 718                 void *data)
 719 {
 720         return pkgmgr_client_usr_uninstall(pc, pkg_type, pkgid, mode, event_cb,
 721                         data, _getuid());
 722 }
 723
 724 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
 725                 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
 726                 void *data, uid_t uid)
 727 {
 728         GVariant *result;
 729         int ret = PKGMGR_R_ECOMM;
 730         char *req_key = NULL;
 731         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 732         char *pkgtype;
 733         pkgmgrinfo_pkginfo_h handle;
 734         struct cb_info *cb_info;
 735
 736         if (pc == NULL || pkgid == NULL) {
 737                 ERR("invalid parameter");
 738                 return PKGMGR_R_EINVAL;
 739         }
 740
 741         if (client->pc_type != PC_REQUEST) {
 742                 ERR("client->pc_type is not PC_REQUEST");
 743                 return PKGMGR_R_EINVAL;
 744         }
 745
 746         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
 747         if (ret < 0)
 748                 return PKGMGR_R_EINVAL;
 749
 750         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
 751         if (ret < 0) {
 752                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 753                 return PKGMGR_R_ERROR;
 754         }
 755
 756         ret = pkgmgr_client_connection_send_request(client, "uninstall",
 757                         g_variant_new("(uss)", uid, pkgtype, pkgid), &result);
 758         if (ret != PKGMGR_R_OK) {
 759                 ERR("request failed: %d", ret);
 760                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 761                 return ret;
 762         }
 763
 764         g_variant_get(result, "(i&s)", &ret, &req_key);
 765         if (req_key == NULL) {
 766                 g_variant_unref(result);
 767                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 768                 return PKGMGR_R_ECOMM;
 769         }
 770         if (ret != PKGMGR_R_OK) {
 771                 g_variant_unref(result);
 772                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 773                 return ret;
 774         }
 775
 776         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
 777         if (cb_info == NULL) {
 778                 g_variant_unref(result);
 779                 return PKGMGR_R_ENOMEM;
 780         }
 781         g_variant_unref(result);
 782         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 783         if (ret != PKGMGR_R_OK) {
 784                 __free_cb_info(cb_info);
 785                 return ret;
 786         }
 787         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 788
 789         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 790
 791         return cb_info->req_id;
 792 }
 793
 794 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
 795                 const char *pkgid, pkgmgr_move_type move_type,
 796                 pkgmgr_handler event_cb, void *data)
 797 {
 798         return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type,
 799                         event_cb, data, _getuid());
 800 }
 801 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
 802                 const char *pkgid, pkgmgr_move_type move_type,
 803                 pkgmgr_handler event_cb, void *data, uid_t uid)
 804 {
 805         GVariant *result;
 806         int ret = PKGMGR_R_ECOMM;
 807         char *req_key = NULL;
 808         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 809         struct cb_info *cb_info;
 810
 811         if (pc == NULL || pkg_type == NULL || pkgid == NULL) {
 812                 ERR("invalid parameter");
 813                 return PKGMGR_R_EINVAL;
 814         }
 815
 816         if ((move_type < PM_MOVE_TO_INTERNAL) ||
 817                         (move_type > PM_MOVE_TO_SDCARD))
 818                 return PKGMGR_R_EINVAL;
 819
 820         if (client->pc_type != PC_REQUEST) {
 821                 ERR("client->pc_type is not PC_REQUEST");
 822                 return PKGMGR_R_EINVAL;
 823         }
 824
 825         ret = pkgmgr_client_connection_send_request(client, "move",
 826                         g_variant_new("(ussi)", uid, pkg_type, pkgid,
 827                                 move_type), &result);
 828         if (ret != PKGMGR_R_OK) {
 829                 ERR("request failed: %d", ret);
 830                 return ret;
 831         }
 832
 833         g_variant_get(result, "(i&s)", &ret, &req_key);
 834         if (req_key == NULL) {
 835                 g_variant_unref(result);
 836                 return PKGMGR_R_ECOMM;
 837         }
 838         if (ret != PKGMGR_R_OK) {
 839                 g_variant_unref(result);
 840                 return ret;
 841         }
 842
 843         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
 844         if (cb_info == NULL) {
 845                 g_variant_unref(result);
 846                 return PKGMGR_R_ERROR;
 847         }
 848         g_variant_unref(result);
 849         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 850         if (ret != PKGMGR_R_OK) {
 851                 __free_cb_info(cb_info);
 852                 return ret;
 853         }
 854         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 855
 856         return cb_info->req_id;
 857 }
 858
 859 API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
 860                 const char *pkgid, uid_t uid)
 861 {
 862         GVariant *result;
 863         int ret = PKGMGR_R_ECOMM;
 864         GVariantBuilder *builder;
 865         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 866
 867         if (pc == NULL || pkgid == NULL || pkg_type == NULL) {
 868                 ERR("invalid parameter");
 869                 return PKGMGR_R_EINVAL;
 870         }
 871
 872         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 873         g_variant_builder_add(builder, "s", pkgid);
 874
 875         ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
 876                         g_variant_new("(usas)", uid, pkg_type, builder),
 877                         &result);
 878         g_variant_builder_unref(builder);
 879         if (ret != PKGMGR_R_OK) {
 880                 ERR("request failed: %d", ret);
 881                 return ret;
 882         }
 883
 884         g_variant_get(result, "(is)", &ret, NULL);
 885         g_variant_unref(result);
 886
 887         return ret;
 888 }
 889
 890 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
 891                 const char *pkgid)
 892 {
 893         return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, _getuid());
 894 }
 895
 896 API int pkgmgr_client_usr_activate_packages(pkgmgr_client *pc,
 897                 const char *pkg_type, const char **pkgids, int n_pkgs,
 898                 pkgmgr_handler event_cb, void *data, uid_t uid)
 899 {
 900         GVariant *result;
 901         GVariantBuilder *builder;
 902         int ret = PKGMGR_R_ECOMM;
 903         char *req_key = NULL;
 904         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 905         struct cb_info *cb_info;
 906         int i;
 907
 908         if (pc == NULL || pkgids == NULL || pkg_type == NULL || n_pkgs < 1) {
 909                 ERR("invalid parameter");
 910                 return PKGMGR_R_EINVAL;
 911         }
 912
 913         if (client->pc_type != PC_REQUEST) {
 914                 ERR("client type is not PC_REQUEST");
 915                 return PKGMGR_R_EINVAL;
 916         }
 917
 918         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 919         for (i = 0; i < n_pkgs; i++)
 920                 g_variant_builder_add(builder, "s", pkgids[i]);
 921
 922         ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
 923                         g_variant_new("(usas)", uid, pkg_type, builder),
 924                         &result);
 925         g_variant_builder_unref(builder);
 926         if (ret != PKGMGR_R_OK) {
 927                 ERR("request failed: %d", ret);
 928                 return ret;
 929         }
 930
 931         g_variant_get(result, "(i&s)", &ret, &req_key);
 932         if (req_key == NULL) {
 933                 g_variant_unref(result);
 934                 return PKGMGR_R_ECOMM;
 935         }
 936         if (ret != PKGMGR_R_OK) {
 937                 g_variant_unref(result);
 938                 return ret;
 939         }
 940
 941         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
 942         if (cb_info == NULL) {
 943                 g_variant_unref(result);
 944                 return PKGMGR_R_ERROR;
 945         }
 946         g_variant_unref(result);
 947         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 948         if (ret != PKGMGR_R_OK) {
 949                 __free_cb_info(cb_info);
 950                 return ret;
 951         }
 952         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 953
 954         return cb_info->req_id;
 955 }
 956
 957 API int pkgmgr_client_activate_packages(pkgmgr_client *pc,
 958                 const char *pkg_type, const char **pkgids, int n_pkgs,
 959                 pkgmgr_handler event_cb, void *data)
 960 {
 961         return pkgmgr_client_usr_activate_packages(pc, pkg_type,
 962                         pkgids, n_pkgs, event_cb, data, _getuid());
 963 }
 964
 965 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
 966                                  const char *pkgid, uid_t uid)
 967 {
 968         GVariant *result;
 969         GVariantBuilder *builder;
 970         int ret = PKGMGR_R_ECOMM;
 971         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 972
 973         if (pc == NULL || pkgid == NULL || pkg_type == NULL) {
 974                 ERR("invalid parameter");
 975                 return PKGMGR_R_EINVAL;
 976         }
 977
 978         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 979         g_variant_builder_add(builder, "s", pkgid);
 980
 981         ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
 982                         g_variant_new("(usas)", uid, pkg_type, builder),
 983                         &result);
 984         g_variant_builder_unref(builder);
 985         if (ret != PKGMGR_R_OK) {
 986                 ERR("request failed: %d", ret);
 987                 return ret;
 988         }
 989
 990         g_variant_get(result, "(is)", &ret, NULL);
 991         g_variant_unref(result);
 992
 993         return ret;
 994 }
 995
 996 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
 997                                  const char *pkgid)
 998 {
 999         return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, _getuid());
1000 }
1001
1002 API int pkgmgr_client_usr_deactivate_packages(pkgmgr_client *pc,
1003                 const char *pkg_type, const char **pkgids, int n_pkgs,
1004                 pkgmgr_handler event_cb, void *data, uid_t uid)
1005 {
1006         GVariant *result;
1007         GVariantBuilder *builder;
1008         int ret = PKGMGR_R_ECOMM;
1009         char *req_key = NULL;
1010         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1011         struct cb_info *cb_info;
1012         int i;
1013
1014         if (pc == NULL || pkgids == NULL || pkg_type == NULL || n_pkgs < 1) {
1015                 ERR("invalid parameter");
1016                 return PKGMGR_R_EINVAL;
1017         }
1018
1019         if (client->pc_type != PC_REQUEST) {
1020                 ERR("client type is not PC_REQUEST");
1021                 return PKGMGR_R_EINVAL;
1022         }
1023
1024         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1025         for (i = 0; i < n_pkgs; i++)
1026                 g_variant_builder_add(builder, "s", pkgids[i]);
1027
1028         ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
1029                 g_variant_new("(usas)", uid, pkg_type, builder), &result);
1030         g_variant_builder_unref(builder);
1031         if (ret != PKGMGR_R_OK) {
1032                 ERR("request failed: %d", ret);
1033                 return ret;
1034         }
1035
1036         g_variant_get(result, "(i&s)", &ret, &req_key);
1037         if (req_key == NULL) {
1038                 g_variant_unref(result);
1039                 return PKGMGR_R_ECOMM;
1040         }
1041         if (ret != PKGMGR_R_OK) {
1042                 g_variant_unref(result);
1043                 return ret;
1044         }
1045
1046         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1047         if (cb_info == NULL) {
1048                 g_variant_unref(result);
1049                 return PKGMGR_R_ERROR;
1050         }
1051         g_variant_unref(result);
1052         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1053         if (ret != PKGMGR_R_OK) {
1054                 __free_cb_info(cb_info);
1055                 return ret;
1056         }
1057         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1058
1059         return cb_info->req_id;
1060 }
1061
1062 API int pkgmgr_client_deactivate_packages(pkgmgr_client *pc,
1063                 const char *pkg_type, const char **pkgids, int n_pkgs,
1064                 pkgmgr_handler event_cb, void *data)
1065 {
1066         return pkgmgr_client_usr_deactivate_packages(pc, pkg_type,
1067                         pkgids, n_pkgs, event_cb, data, _getuid());
1068 }
1069
1070 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
1071                 pkgmgr_app_handler app_event_cb, uid_t uid)
1072 {
1073         GVariant *result;
1074         int ret = PKGMGR_R_ECOMM;
1075         char *req_key = NULL;
1076         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1077         struct cb_info *cb_info;
1078
1079         if (pc == NULL || appid == NULL) {
1080                 ERR("invalid parameter");
1081                 return PKGMGR_R_EINVAL;
1082         }
1083
1084         ret = pkgmgr_client_connection_send_request(client, "enable_app",
1085                         g_variant_new("(us)", uid, appid), &result);
1086         if (ret != PKGMGR_R_OK) {
1087                 ERR("request failed: %d", ret);
1088                 return ret;
1089         }
1090
1091         g_variant_get(result, "(i&s)", &ret, &req_key);
1092         if (req_key == NULL) {
1093                 g_variant_unref(result);
1094                 return PKGMGR_R_ECOMM;
1095         }
1096         if (ret != PKGMGR_R_OK) {
1097                 g_variant_unref(result);
1098                 return ret;
1099         }
1100
1101         cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1102                         req_key);
1103         if (cb_info == NULL) {
1104                 g_variant_unref(result);
1105                 return PKGMGR_R_ENOMEM;
1106         }
1107         g_variant_unref(result);
1108         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1109         if (ret != PKGMGR_R_OK) {
1110                 __free_cb_info(cb_info);
1111                 return ret;
1112         }
1113         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1114
1115         return PKGMGR_R_OK;
1116 }
1117
1118 API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid,
1119                 pkgmgr_app_handler app_event_cb)
1120 {
1121         return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb,
1122                         _getuid());
1123 }
1124
1125 API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
1126                 const char *appid, pkgmgr_app_handler app_event_cb, uid_t uid)
1127 {
1128         GVariant *result;
1129         int ret = PKGMGR_R_ECOMM;
1130         char *req_key = NULL;
1131         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1132         struct cb_info *cb_info;
1133
1134         if (pc == NULL || appid == NULL) {
1135                 ERR("invalid parameter");
1136                 return PKGMGR_R_EINVAL;
1137         }
1138
1139         ret = pkgmgr_client_connection_send_request(client,
1140                         "enable_global_app_for_uid",
1141                         g_variant_new("(us)", uid, appid), &result);
1142         if (ret != PKGMGR_R_OK) {
1143                 ERR("request failed: %d", ret);
1144                 return ret;
1145         }
1146
1147         g_variant_get(result, "(i&s)", &ret, &req_key);
1148         if (req_key == NULL) {
1149                 g_variant_unref(result);
1150                 return PKGMGR_R_ECOMM;
1151         }
1152         if (ret != PKGMGR_R_OK) {
1153                 g_variant_unref(result);
1154                 return ret;
1155         }
1156
1157         cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1158                         req_key);
1159         if (cb_info == NULL) {
1160                 g_variant_unref(result);
1161                 return PKGMGR_R_ENOMEM;
1162         }
1163         g_variant_unref(result);
1164         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1165         if (ret != PKGMGR_R_OK) {
1166                 __free_cb_info(cb_info);
1167                 return ret;
1168         }
1169         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1170
1171         return PKGMGR_R_OK;
1172 }
1173
1174 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1175                 pkgmgr_app_handler app_event_cb, uid_t uid)
1176 {
1177         GVariant *result;
1178         int ret = PKGMGR_R_ECOMM;
1179         char *req_key = NULL;
1180         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1181         struct cb_info *cb_info;
1182
1183         if (pc == NULL || appid == NULL) {
1184                 ERR("invalid parameter");
1185                 return PKGMGR_R_EINVAL;
1186         }
1187
1188         ret = pkgmgr_client_connection_send_request(client, "disable_app",
1189                         g_variant_new("(us)", uid, appid), &result);
1190         if (ret != PKGMGR_R_OK) {
1191                 ERR("request failed: %d", ret);
1192                 return ret;
1193         }
1194
1195         g_variant_get(result, "(i&s)", &ret, &req_key);
1196         if (req_key == NULL) {
1197                 g_variant_unref(result);
1198                 return PKGMGR_R_ECOMM;
1199         }
1200         if (ret != PKGMGR_R_OK) {
1201                 g_variant_unref(result);
1202                 return ret;
1203         }
1204
1205         cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1206                         req_key);
1207         if (cb_info == NULL) {
1208                 g_variant_unref(result);
1209                 return PKGMGR_R_ENOMEM;
1210         }
1211         g_variant_unref(result);
1212         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1213         if (ret != PKGMGR_R_OK) {
1214                 __free_cb_info(cb_info);
1215                 return ret;
1216         }
1217         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1218
1219         return PKGMGR_R_OK;
1220 }
1221
1222 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid,
1223                 pkgmgr_app_handler app_event_cb)
1224 {
1225         return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb,
1226                         _getuid());
1227 }
1228
1229 API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
1230                 const char *appid, pkgmgr_app_handler app_event_cb, uid_t uid)
1231 {
1232         GVariant *result;
1233         int ret = PKGMGR_R_ECOMM;
1234         char *req_key = NULL;
1235         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1236         struct cb_info *cb_info;
1237
1238         if (pc == NULL || appid == NULL) {
1239                 ERR("invalid parameter");
1240                 return PKGMGR_R_EINVAL;
1241         }
1242
1243         ret = pkgmgr_client_connection_send_request(client,
1244                         "disable_global_app_for_uid",
1245                         g_variant_new("(us)", uid, appid), &result);
1246         if (ret != PKGMGR_R_OK) {
1247                 ERR("request failed: %d", ret);
1248                 return ret;
1249         }
1250
1251         g_variant_get(result, "(i&s)", &ret, &req_key);
1252         if (req_key == NULL) {
1253                 g_variant_unref(result);
1254                 return PKGMGR_R_ECOMM;
1255         }
1256         if (ret != PKGMGR_R_OK) {
1257                 g_variant_unref(result);
1258                 return ret;
1259         }
1260
1261         cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1262                         req_key);
1263         if (cb_info == NULL) {
1264                 g_variant_unref(result);
1265                 return PKGMGR_R_ENOMEM;
1266         }
1267         g_variant_unref(result);
1268         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1269         if (ret != PKGMGR_R_OK) {
1270                 __free_cb_info(cb_info);
1271                 return ret;
1272         }
1273         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1274
1275         return PKGMGR_R_OK;
1276 }
1277
1278 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1279                 const char *pkg_type, const char *appid, pkgmgr_mode mode,
1280                 uid_t uid)
1281 {
1282         GVariant *result;
1283         int ret;
1284         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1285
1286         if (pc == NULL || pkg_type == NULL || appid == NULL) {
1287                 ERR("invalid parameter");
1288                 return PKGMGR_R_EINVAL;
1289         }
1290
1291         if (client->pc_type != PC_REQUEST) {
1292                 ERR("client->pc_type is not PC_REQUEST");
1293                 return PKGMGR_R_EINVAL;
1294         }
1295
1296         ret = pkgmgr_client_connection_send_request(client, "cleardata",
1297                         g_variant_new("(uss)", uid, pkg_type, appid), &result);
1298         if (ret == PKGMGR_R_OK) {
1299                 ERR("request failed: %d", ret);
1300                 return ret;
1301         }
1302
1303         g_variant_get(result, "(i)", &ret);
1304         g_variant_unref(result);
1305
1306         return ret;
1307 }
1308
1309 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1310                 const char *appid, pkgmgr_mode mode)
1311 {
1312         return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid, mode,
1313                         _getuid());
1314 }
1315
1316 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1317 {
1318         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1319
1320         if (pc == NULL) {
1321                 ERR("invalid parameter");
1322                 return PKGMGR_R_EINVAL;
1323         }
1324
1325         client->status_type = status_type;
1326
1327         return PKGMGR_R_OK;
1328 }
1329
1330 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1331                 void *data)
1332 {
1333         int ret;
1334         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1335         struct cb_info *cb_info;
1336
1337         if (pc == NULL || event_cb == NULL) {
1338                 ERR("invalid parameter");
1339                 return PKGMGR_R_EINVAL;
1340         }
1341
1342         if (client->pc_type != PC_LISTENING) {
1343                 ERR("client->pc_type is not PC_LISTENING");
1344                 return PKGMGR_R_EINVAL;
1345         }
1346
1347         cb_info = __create_event_cb_info(client, event_cb, data, NULL);
1348         if (cb_info == NULL)
1349                 return PKGMGR_R_ENOMEM;
1350         cb_info->status_type = client->status_type;
1351         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1352         if (ret != PKGMGR_R_OK) {
1353                 __free_cb_info(cb_info);
1354                 return ret;
1355         }
1356         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1357
1358         return cb_info->req_id;
1359 }
1360
1361 API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
1362                 pkgmgr_app_handler app_event_cb, void *data)
1363 {
1364         int ret;
1365         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1366         struct cb_info *cb_info;
1367
1368         if (pc == NULL || app_event_cb == NULL) {
1369                 ERR("invalid parameter");
1370                 return PKGMGR_R_EINVAL;
1371         }
1372
1373         if (client->pc_type != PC_LISTENING) {
1374                 ERR("client->pc_type is not PC_LISTENING");
1375                 return PKGMGR_R_EINVAL;
1376         }
1377
1378         cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL);
1379         if (cb_info == NULL)
1380                 return PKGMGR_R_ENOMEM;
1381         cb_info->status_type = client->status_type;
1382         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1383         if (ret != PKGMGR_R_OK) {
1384                 __free_cb_info(cb_info);
1385                 return ret;
1386         }
1387         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1388
1389         return cb_info->req_id;
1390 }
1391
1392 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
1393 {
1394         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1395         GList *tmp;
1396         GList *next;
1397         struct cb_info *cb_info;
1398
1399         if (pc == NULL) {
1400                 ERR("invalid parameter");
1401                 return PKGMGR_R_EINVAL;
1402         }
1403
1404         /* unset all callback */
1405         tmp = client->cb_info_list;
1406         while (tmp != NULL) {
1407                 next = tmp->next;
1408                 cb_info = (struct cb_info *)tmp->data;
1409                 pkgmgr_client_connection_unset_callback(pc, cb_info);
1410                 client->cb_info_list = g_list_delete_link(client->cb_info_list,
1411                                 tmp);
1412                 __free_cb_info(cb_info);
1413                 tmp = next;
1414         }
1415
1416         return PKGMGR_R_OK;
1417 }
1418
1419 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1420                 const char *pkgid, const char *key, const char *val)
1421 {
1422         /* client cannot broadcast signal */
1423         return PKGMGR_R_OK;
1424 }
1425
1426 /* TODO: deprecate(or remove) */
1427 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
1428                 int service_mode, pkgmgr_client *pc, const char *pkg_type,
1429                 const char *pkgid, const char *custom_info,
1430                 pkgmgr_handler event_cb, void *data)
1431 {
1432         return pkgmgr_client_usr_request_service(service_type, service_mode,
1433                         pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
1434                         data);
1435 }
1436
1437 API int pkgmgr_client_usr_request_service(
1438                 pkgmgr_request_service_type service_type, int service_mode,
1439                 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
1440                 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
1441                 void *data)
1442 {
1443         int ret = 0;
1444
1445         /* Check for NULL value of service type */
1446         retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1447         retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1448
1449         switch (service_type) {
1450         case PM_REQUEST_MOVE:
1451                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1452                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1453                 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1454
1455                 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1456                 break;
1457
1458         case PM_REQUEST_GET_SIZE:
1459                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1460                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1461                 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1462
1463                 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1464                 break;
1465
1466         case PM_REQUEST_KILL_APP:
1467         case PM_REQUEST_CHECK_APP:
1468                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1469                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1470
1471                 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1472                 if (ret < 0)
1473                         ERR("__check_app_process fail \n");
1474                 else
1475                         ret = PKGMGR_R_OK;
1476
1477                 break;
1478
1479         default:
1480                 ERR("Wrong Request\n");
1481                 ret = -1;
1482                 break;
1483         }
1484
1485 catch:
1486
1487         return ret;
1488 }
1489
1490
1491 API int pkgmgr_client_usr_request_size_info(uid_t uid)
1492 {
1493         int ret;
1494         struct pkgmgr_client *client;
1495
1496         client = pkgmgr_client_new(PC_REQUEST);
1497         if (client == NULL) {
1498                 ERR("out of memory");
1499                 return PKGMGR_R_ENOMEM;
1500         }
1501
1502         ret = __request_size_info(client, uid);
1503         if (ret < 0)
1504                 ERR("__request_size_info fail");
1505
1506         pkgmgr_client_free(client);
1507         return ret;
1508 }
1509
1510 API int pkgmgr_client_request_size_info(void)
1511 {
1512         /* get all package size (data, total) */
1513         return pkgmgr_client_usr_request_size_info(_getuid());
1514 }
1515
1516 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1517 {
1518         GVariant *result;
1519         int ret;
1520         struct pkgmgr_client_t *client;
1521
1522         if (pkgid == NULL) {
1523                 ERR("invalid parameter");
1524                 return PKGMGR_R_EINVAL;
1525         }
1526
1527         client = pkgmgr_client_new(PC_REQUEST);
1528         if (client == NULL) {
1529                 ERR("out of memory");
1530                 return PKGMGR_R_ENOMEM;
1531         }
1532
1533         ret = pkgmgr_client_connection_send_request(client, "clearcache",
1534                         g_variant_new("(us)", uid, pkgid), &result);
1535         if (ret != PKGMGR_R_OK) {
1536                 ERR("request failed: %d", ret);
1537                 return ret;
1538         }
1539
1540         g_variant_get(result, "(i)", &ret);
1541         g_variant_unref(result);
1542
1543         return ret;
1544 }
1545
1546 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1547 {
1548         return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
1549 }
1550
1551 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1552 {
1553         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1554 }
1555
1556 API int pkgmgr_client_clear_all_cache_dir(void)
1557 {
1558         return pkgmgr_client_usr_clear_cache_dir(
1559                         PKG_CLEAR_ALL_CACHE, getuid());
1560 }
1561
1562 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
1563                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1564                 void *data)
1565 {
1566         return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
1567                         _getuid());
1568 }
1569
1570 /* TODO: deprecate(or remove) */
1571 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
1572                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1573                 void *data, uid_t uid)
1574 {
1575         GVariant *result;
1576         int ret = PKGMGR_R_ECOMM;
1577         char *req_key = NULL;
1578         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1579         struct cb_info *cb_info;
1580
1581         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1582                 ERR("invalid parameter");
1583                 return PKGMGR_R_EINVAL;
1584         }
1585
1586         if (client->pc_type != PC_REQUEST) {
1587                 ERR("client->pc_type is not PC_REQUEST");
1588                 return PKGMGR_R_EINVAL;
1589         }
1590
1591         /* FIXME */
1592         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1593                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1594         else
1595                 get_type = PM_GET_PKG_SIZE_INFO;
1596
1597         ret = pkgmgr_client_connection_send_request(client, "getsize",
1598                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
1599         if (ret != PKGMGR_R_OK) {
1600                 ERR("request failed: %d", ret);
1601                 return ret;
1602         }
1603
1604         g_variant_get(result, "(i&s)", &ret, &req_key);
1605         if (req_key == NULL) {
1606                 g_variant_unref(result);
1607                 return PKGMGR_R_ECOMM;
1608         }
1609         if (ret != PKGMGR_R_OK) {
1610                 g_variant_unref(result);
1611                 return ret;
1612         }
1613
1614         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1615         if (cb_info == NULL) {
1616                 g_variant_unref(result);
1617                 return PKGMGR_R_ENOMEM;
1618         }
1619         g_variant_unref(result);
1620         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1621         if (ret != PKGMGR_R_OK) {
1622                 __free_cb_info(cb_info);
1623                 return ret;
1624         }
1625         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1626
1627         return PKGMGR_R_OK;
1628 }
1629
1630 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
1631                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1632                 void *user_data, uid_t uid)
1633 {
1634         GVariant *result;
1635         int ret = PKGMGR_R_ECOMM;
1636         char *req_key = NULL;
1637         int get_type;
1638         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1639         struct cb_info *cb_info;
1640
1641         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1642                 ERR("invalid parameter");
1643                 return PKGMGR_R_EINVAL;
1644         }
1645
1646         if (client->pc_type != PC_REQUEST) {
1647                 ERR("client->pc_type is not PC_REQUEST");
1648                 return PKGMGR_R_EINVAL;
1649         }
1650
1651         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1652                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1653         else
1654                 get_type = PM_GET_PKG_SIZE_INFO;
1655
1656         ret = pkgmgr_client_connection_send_request(client, "getsize",
1657                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
1658         if (ret != PKGMGR_R_OK) {
1659                 ERR("request failed: %d", ret);
1660                 return ret;
1661         }
1662
1663         g_variant_get(result, "(i&s)", &ret, &req_key);
1664         if (req_key == NULL) {
1665                 g_variant_unref(result);
1666                 return PKGMGR_R_ECOMM;
1667         }
1668         if (ret != PKGMGR_R_OK) {
1669                 g_variant_unref(result);
1670                 return ret;
1671         }
1672
1673         cb_info = __create_size_info_cb_info(client, event_cb, user_data,
1674                         req_key);
1675         if (cb_info == NULL) {
1676                 g_variant_unref(result);
1677                 return PKGMGR_R_ENOMEM;
1678         }
1679         g_variant_unref(result);
1680         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1681         if (ret != PKGMGR_R_OK) {
1682                 __free_cb_info(cb_info);
1683                 return ret;
1684         }
1685         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1686
1687         return PKGMGR_R_OK;
1688 }
1689
1690 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
1691                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1692                 void *user_data)
1693 {
1694         return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
1695                         user_data, _getuid());
1696 }
1697
1698 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
1699                 pkgmgr_total_pkg_size_info_receive_cb event_cb,
1700                 void *user_data, uid_t uid)
1701 {       /* total package size info */
1702         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1703                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
1704                         user_data, uid);
1705 }
1706
1707 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
1708                 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
1709 {
1710         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1711                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
1712                         user_data, _getuid());
1713 }
1714
1715 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
1716                 const char *resp_data, char **req_data, char **license_url)
1717 {
1718         GVariant *result;
1719         int ret;
1720         char *data;
1721         char *url;
1722         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1723
1724         if (pc == NULL || resp_data == NULL || req_data == NULL ||
1725                         license_url == NULL) {
1726                 ERR("invalid parameter");
1727                 return PKGMGR_R_EINVAL;
1728         }
1729
1730         if (client->pc_type != PC_REQUEST) {
1731                 ERR("client->pc_type is not PC_REQUEST");
1732                 return PKGMGR_R_EINVAL;
1733         }
1734
1735         ret = pkgmgr_client_connection_send_request(client,
1736                         "generate_license_request",
1737                         g_variant_new("(s)", resp_data), &result);
1738         if (ret != PKGMGR_R_OK) {
1739                 ERR("request failed: %d", ret);
1740                 return ret;
1741         }
1742
1743         g_variant_get(result, "(i&s&s)", &ret, &data, &url);
1744         if (ret != PKGMGR_R_OK) {
1745                 ERR("generate_license_request failed: %d", ret);
1746                 g_variant_unref(result);
1747                 return ret;
1748         }
1749
1750         *req_data = strdup(data);
1751         *license_url = strdup(url);
1752
1753         g_variant_unref(result);
1754
1755         return PKGMGR_R_OK;
1756 }
1757
1758 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
1759 {
1760         GVariant *result;
1761         int ret;
1762         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1763
1764         if (pc == NULL || resp_data == NULL) {
1765                 ERR("invalid parameter");
1766                 return PKGMGR_R_EINVAL;
1767         }
1768
1769         if (client->pc_type != PC_REQUEST) {
1770                 ERR("client->pc_type is not PC_REQUEST");
1771                 return PKGMGR_R_EINVAL;
1772         }
1773
1774         ret = pkgmgr_client_connection_send_request(client, "register_license",
1775                         g_variant_new("(s)", resp_data), &result);
1776         if (ret != PKGMGR_R_OK) {
1777                 ERR("request failed: %d", ret);
1778                 return ret;
1779         }
1780
1781         g_variant_get(result, "(i)", &ret);
1782         g_variant_unref(result);
1783         if (ret != PKGMGR_R_OK)
1784                 ERR("register license failed: %d", ret);
1785
1786         return ret;
1787 }
1788
1789 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
1790                 const char *drm_file_path, const char *decrypted_file_path)
1791 {
1792         GVariant *result;
1793         int ret;
1794         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1795
1796         if (pc == NULL || drm_file_path == NULL ||
1797                         decrypted_file_path == NULL) {
1798                 ERR("invalid parameter");
1799                 return PKGMGR_R_EINVAL;
1800         }
1801
1802         if (client->pc_type != PC_REQUEST) {
1803                 ERR("client->pc_type is not PC_REQUEST");
1804                 return PKGMGR_R_EINVAL;
1805         }
1806
1807         ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
1808                         g_variant_new("(ss)", drm_file_path,
1809                                 decrypted_file_path), &result);
1810         if (ret != PKGMGR_R_OK) {
1811                 ERR("request failed: %d", ret);
1812                 return ret;
1813         }
1814
1815         g_variant_get(result, "(i)", &ret);
1816         g_variant_unref(result);
1817         if (ret != PKGMGR_R_OK)
1818                 ERR("decrypt_package failed: %d", ret);
1819
1820         return ret;
1821 }
1822
1823 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
1824 {
1825         return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
1826 }
1827
1828 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
1829                 const char *appid, uid_t uid)
1830 {
1831         int ret;
1832         GVariant *result;
1833         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1834
1835         if (pc == NULL || appid == NULL) {
1836                 ERR("Invalid parameter");
1837                 return PKGMGR_R_EINVAL;
1838         }
1839
1840         ret = pkgmgr_client_connection_send_request(client,
1841                         "enable_app_splash_screen",
1842                         g_variant_new("(us)", uid, appid), &result);
1843         if (ret != PKGMGR_R_OK) {
1844                 ERR("request failed: %d", ret);
1845                 return ret;
1846         }
1847
1848         g_variant_get(result, "(i)", &ret);
1849         g_variant_unref(result);
1850         if (ret != PKGMGR_R_OK)
1851                 ERR("enable splash screen failed: %d", ret);
1852
1853         return ret;
1854 }
1855
1856 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
1857                 const char *appid)
1858 {
1859         return pkgmgr_client_usr_disable_splash_screen(pc, appid,
1860                         _getuid());
1861 }
1862
1863 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
1864                 const char *appid, uid_t uid)
1865 {
1866         int ret;
1867         GVariant *result;
1868         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1869
1870         if (pc == NULL || appid == NULL) {
1871                 ERR("Invalid parameter");
1872                 return PKGMGR_R_EINVAL;
1873         }
1874
1875         ret = pkgmgr_client_connection_send_request(client,
1876                         "disable_app_splash_screen",
1877                         g_variant_new("(us)", uid, appid), &result);
1878         if (ret != PKGMGR_R_OK) {
1879                 ERR("request failed: %d", ret);
1880                 return ret;
1881         }
1882
1883         g_variant_get(result, "(i)", &ret);
1884         g_variant_unref(result);
1885         if (ret != PKGMGR_R_OK)
1886                 ERR("disable splash screen failed: %d", ret);
1887
1888         return ret;
1889 }
1890
1891 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1892                 int mode, uid_t uid)
1893 {
1894         GVariant *result;
1895         int ret = PKGMGR_R_ECOMM;
1896         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1897
1898         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1899                 ERR("invalid parameter");
1900                 return PKGMGR_R_EINVAL;
1901         }
1902
1903         ret = pkgmgr_client_connection_send_request(client,
1904                         "set_restriction_mode",
1905                         g_variant_new("(usi)", uid, pkgid, mode), &result);
1906         if (ret != PKGMGR_R_OK) {
1907                 ERR("request failed: %d", ret);
1908                 return ret;
1909         }
1910
1911         g_variant_get(result, "(i)", &ret);
1912         g_variant_unref(result);
1913
1914         return ret;
1915 }
1916
1917 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
1918                 const char *pkgid, int mode, uid_t uid)
1919 {
1920         return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
1921 }
1922
1923 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
1924                 const char *pkgid, int mode)
1925 {
1926         return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
1927                         _getuid());
1928 }
1929
1930 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1931                 int mode, uid_t uid)
1932 {
1933         GVariant *result;
1934         int ret = PKGMGR_R_ECOMM;
1935         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1936
1937         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1938                 ERR("invalid parameter");
1939                 return PKGMGR_R_EINVAL;
1940         }
1941
1942         ret = pkgmgr_client_connection_send_request(client,
1943                         "unset_restriction_mode",
1944                         g_variant_new("(usi)", uid, pkgid, mode), &result);
1945         if (ret != PKGMGR_R_OK) {
1946                 ERR("request failed: %d", ret);
1947                 return ret;
1948         }
1949
1950         g_variant_get(result, "(i)", &ret);
1951         g_variant_unref(result);
1952
1953         return ret;
1954
1955 }
1956
1957 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
1958                 const char *pkgid, int mode, uid_t uid)
1959 {
1960         return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
1961 }
1962
1963 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
1964                 const char *pkgid, int mode)
1965 {
1966         return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
1967                         _getuid());
1968 }
1969
1970 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1971                 int *mode, uid_t uid)
1972 {
1973         GVariant *result;
1974         int ret = PKGMGR_R_ECOMM;
1975         gint m;
1976         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1977
1978         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
1979                 ERR("invalid parameter");
1980                 return PKGMGR_R_EINVAL;
1981         }
1982
1983         ret = pkgmgr_client_connection_send_request(client,
1984                         "get_restriction_mode",
1985                         g_variant_new("(us)", uid, pkgid), &result);
1986         if (ret != PKGMGR_R_OK) {
1987                 ERR("request failed: %d", ret);
1988                 return ret;
1989         }
1990
1991         g_variant_get(result, "(ii)", &m, &ret);
1992         g_variant_unref(result);
1993         if (ret != PKGMGR_R_OK)
1994                 return ret;
1995
1996         *mode = m;
1997
1998         return PKGMGR_R_OK;
1999 }
2000
2001 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
2002                 const char *pkgid, int *mode, uid_t uid)
2003 {
2004         return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
2005 }
2006
2007 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
2008                 const char *pkgid, int *mode)
2009 {
2010         return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
2011                         _getuid());
2012 }
2013
2014 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
2015                 uid_t uid)
2016 {
2017         GVariant *result;
2018         int ret = PKGMGR_R_ECOMM;
2019         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2020
2021         if (pc == NULL) {
2022                 ERR("invalid parameter");
2023                 return PKGMGR_R_EINVAL;
2024         }
2025
2026         ret = pkgmgr_client_connection_send_request(client,
2027                         "set_restriction_mode",
2028                         g_variant_new("(usi)", uid, "", mode), &result);
2029         if (ret != PKGMGR_R_OK) {
2030                 ERR("request failed: %d", ret);
2031                 return ret;
2032         }
2033
2034         g_variant_get(result, "(i)", &ret);
2035         g_variant_unref(result);
2036
2037         return ret;
2038 }
2039
2040 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
2041 {
2042         return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
2043 }
2044
2045 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
2046                 uid_t uid)
2047 {
2048         GVariant *result;
2049         int ret = PKGMGR_R_ECOMM;
2050         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2051
2052         if (pc == NULL) {
2053                 ERR("invalid parameter");
2054                 return PKGMGR_R_EINVAL;
2055         }
2056
2057         ret = pkgmgr_client_connection_send_request(client,
2058                         "unset_restriction_mode",
2059                         g_variant_new("(usi)", uid, "", mode), &result);
2060         if (ret != PKGMGR_R_OK) {
2061                 ERR("request failed: %d", ret);
2062                 return ret;
2063         }
2064
2065         g_variant_get(result, "(i)", &ret);
2066         g_variant_unref(result);
2067
2068         return ret;
2069 }
2070
2071 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
2072 {
2073         return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
2074 }
2075
2076 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
2077                 int *mode, uid_t uid)
2078 {
2079         GVariant *result;
2080         int ret = PKGMGR_R_ECOMM;
2081         gint m;
2082         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2083
2084         if (pc == NULL) {
2085                 ERR("invalid parameter");
2086                 return PKGMGR_R_EINVAL;
2087         }
2088
2089         ret = pkgmgr_client_connection_send_request(client,
2090                         "get_restriction_mode",
2091                         g_variant_new("(us)", uid, ""), &result);
2092         if (ret != PKGMGR_R_OK) {
2093                 ERR("request failed: %d", ret);
2094                 return ret;
2095         }
2096
2097         g_variant_get(result, "(ii)", &m, &ret);
2098         g_variant_unref(result);
2099         if (ret != PKGMGR_R_OK)
2100                 return ret;
2101
2102         *mode = m;
2103
2104         return PKGMGR_R_OK;
2105 }
2106
2107 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
2108 {
2109         return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
2110 }