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         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 865
 866         if (pc == NULL || pkgid == NULL || pkg_type == NULL) {
 867                 ERR("invalid parameter");
 868                 return PKGMGR_R_EINVAL;
 869         }
 870
 871         ret = pkgmgr_client_connection_send_request(client, "enable_pkg",
 872                         g_variant_new("(uss)", uid, pkg_type, pkgid), &result);
 873         if (ret != PKGMGR_R_OK) {
 874                 ERR("request failed: %d", ret);
 875                 return ret;
 876         }
 877
 878         g_variant_get(result, "(i)", &ret);
 879         g_variant_unref(result);
 880
 881         return ret;
 882 }
 883
 884 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
 885                 const char *pkgid)
 886 {
 887         return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, _getuid());
 888 }
 889
 890 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
 891                                  const char *pkgid, uid_t uid)
 892 {
 893         GVariant *result;
 894         int ret = PKGMGR_R_ECOMM;
 895         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 896
 897         if (pc == NULL || pkgid == NULL || pkg_type == NULL) {
 898                 ERR("invalid parameter");
 899                 return PKGMGR_R_EINVAL;
 900         }
 901
 902         ret = pkgmgr_client_connection_send_request(client, "disable_pkg",
 903                         g_variant_new("(uss)", uid, pkg_type, pkgid), &result);
 904         if (ret != PKGMGR_R_OK) {
 905                 ERR("request failed: %d", ret);
 906                 return ret;
 907         }
 908
 909         g_variant_get(result, "(i)", &ret);
 910         g_variant_unref(result);
 911
 912         return ret;
 913 }
 914
 915 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
 916                                  const char *pkgid)
 917 {
 918         return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, _getuid());
 919 }
 920
 921 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
 922                 pkgmgr_app_handler app_event_cb, uid_t uid)
 923 {
 924         GVariant *result;
 925         int ret = PKGMGR_R_ECOMM;
 926         char *req_key = NULL;
 927         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 928         struct cb_info *cb_info;
 929
 930         if (pc == NULL || appid == NULL) {
 931                 ERR("invalid parameter");
 932                 return PKGMGR_R_EINVAL;
 933         }
 934
 935         ret = pkgmgr_client_connection_send_request(client, "enable_app",
 936                         g_variant_new("(us)", uid, appid), &result);
 937         if (ret != PKGMGR_R_OK) {
 938                 ERR("request failed: %d", ret);
 939                 return ret;
 940         }
 941
 942         g_variant_get(result, "(i&s)", &ret, &req_key);
 943         if (req_key == NULL) {
 944                 g_variant_unref(result);
 945                 return PKGMGR_R_ECOMM;
 946         }
 947         if (ret != PKGMGR_R_OK) {
 948                 g_variant_unref(result);
 949                 return ret;
 950         }
 951
 952         cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
 953                         req_key);
 954         if (cb_info == NULL) {
 955                 g_variant_unref(result);
 956                 return PKGMGR_R_ENOMEM;
 957         }
 958         g_variant_unref(result);
 959         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 960         if (ret != PKGMGR_R_OK) {
 961                 __free_cb_info(cb_info);
 962                 return ret;
 963         }
 964         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 965
 966         return PKGMGR_R_OK;
 967 }
 968
 969 API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid,
 970                 pkgmgr_app_handler app_event_cb)
 971 {
 972         return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb,
 973                         _getuid());
 974 }
 975
 976 API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
 977                 const char *appid, pkgmgr_app_handler app_event_cb, uid_t uid)
 978 {
 979         GVariant *result;
 980         int ret = PKGMGR_R_ECOMM;
 981         char *req_key = NULL;
 982         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 983         struct cb_info *cb_info;
 984
 985         if (pc == NULL || appid == NULL) {
 986                 ERR("invalid parameter");
 987                 return PKGMGR_R_EINVAL;
 988         }
 989
 990         ret = pkgmgr_client_connection_send_request(client,
 991                         "enable_global_app_for_uid",
 992                         g_variant_new("(us)", uid, appid), &result);
 993         if (ret != PKGMGR_R_OK) {
 994                 ERR("request failed: %d", ret);
 995                 return ret;
 996         }
 997
 998         g_variant_get(result, "(i&s)", &ret, &req_key);
 999         if (req_key == NULL) {
1000                 g_variant_unref(result);
1001                 return PKGMGR_R_ECOMM;
1002         }
1003         if (ret != PKGMGR_R_OK) {
1004                 g_variant_unref(result);
1005                 return ret;
1006         }
1007
1008         cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1009                         req_key);
1010         if (cb_info == NULL) {
1011                 g_variant_unref(result);
1012                 return PKGMGR_R_ENOMEM;
1013         }
1014         g_variant_unref(result);
1015         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1016         if (ret != PKGMGR_R_OK) {
1017                 __free_cb_info(cb_info);
1018                 return ret;
1019         }
1020         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1021
1022         return PKGMGR_R_OK;
1023 }
1024
1025 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1026                 pkgmgr_app_handler app_event_cb, uid_t uid)
1027 {
1028         GVariant *result;
1029         int ret = PKGMGR_R_ECOMM;
1030         char *req_key = NULL;
1031         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1032         struct cb_info *cb_info;
1033
1034         if (pc == NULL || appid == NULL) {
1035                 ERR("invalid parameter");
1036                 return PKGMGR_R_EINVAL;
1037         }
1038
1039         ret = pkgmgr_client_connection_send_request(client, "disable_app",
1040                         g_variant_new("(us)", uid, appid), &result);
1041         if (ret != PKGMGR_R_OK) {
1042                 ERR("request failed: %d", ret);
1043                 return ret;
1044         }
1045
1046         g_variant_get(result, "(i&s)", &ret, &req_key);
1047         if (req_key == NULL) {
1048                 g_variant_unref(result);
1049                 return PKGMGR_R_ECOMM;
1050         }
1051         if (ret != PKGMGR_R_OK) {
1052                 g_variant_unref(result);
1053                 return ret;
1054         }
1055
1056         cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1057                         req_key);
1058         if (cb_info == NULL) {
1059                 g_variant_unref(result);
1060                 return PKGMGR_R_ENOMEM;
1061         }
1062         g_variant_unref(result);
1063         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1064         if (ret != PKGMGR_R_OK) {
1065                 __free_cb_info(cb_info);
1066                 return ret;
1067         }
1068         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1069
1070         return PKGMGR_R_OK;
1071 }
1072
1073 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid,
1074                 pkgmgr_app_handler app_event_cb)
1075 {
1076         return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb,
1077                         _getuid());
1078 }
1079
1080 API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
1081                 const char *appid, pkgmgr_app_handler app_event_cb, uid_t uid)
1082 {
1083         GVariant *result;
1084         int ret = PKGMGR_R_ECOMM;
1085         char *req_key = NULL;
1086         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1087         struct cb_info *cb_info;
1088
1089         if (pc == NULL || appid == NULL) {
1090                 ERR("invalid parameter");
1091                 return PKGMGR_R_EINVAL;
1092         }
1093
1094         ret = pkgmgr_client_connection_send_request(client,
1095                         "disable_global_app_for_uid",
1096                         g_variant_new("(us)", uid, appid), &result);
1097         if (ret != PKGMGR_R_OK) {
1098                 ERR("request failed: %d", ret);
1099                 return ret;
1100         }
1101
1102         g_variant_get(result, "(i&s)", &ret, &req_key);
1103         if (req_key == NULL) {
1104                 g_variant_unref(result);
1105                 return PKGMGR_R_ECOMM;
1106         }
1107         if (ret != PKGMGR_R_OK) {
1108                 g_variant_unref(result);
1109                 return ret;
1110         }
1111
1112         cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1113                         req_key);
1114         if (cb_info == NULL) {
1115                 g_variant_unref(result);
1116                 return PKGMGR_R_ENOMEM;
1117         }
1118         g_variant_unref(result);
1119         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1120         if (ret != PKGMGR_R_OK) {
1121                 __free_cb_info(cb_info);
1122                 return ret;
1123         }
1124         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1125
1126         return PKGMGR_R_OK;
1127 }
1128
1129 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1130                 const char *pkg_type, const char *appid, pkgmgr_mode mode,
1131                 uid_t uid)
1132 {
1133         GVariant *result;
1134         int ret;
1135         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1136
1137         if (pc == NULL || pkg_type == NULL || appid == NULL) {
1138                 ERR("invalid parameter");
1139                 return PKGMGR_R_EINVAL;
1140         }
1141
1142         if (client->pc_type != PC_REQUEST) {
1143                 ERR("client->pc_type is not PC_REQUEST");
1144                 return PKGMGR_R_EINVAL;
1145         }
1146
1147         ret = pkgmgr_client_connection_send_request(client, "cleardata",
1148                         g_variant_new("(uss)", uid, pkg_type, appid), &result);
1149         if (ret == PKGMGR_R_OK) {
1150                 ERR("request failed: %d", ret);
1151                 return ret;
1152         }
1153
1154         g_variant_get(result, "(i)", &ret);
1155         g_variant_unref(result);
1156
1157         return ret;
1158 }
1159
1160 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1161                 const char *appid, pkgmgr_mode mode)
1162 {
1163         return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid, mode,
1164                         _getuid());
1165 }
1166
1167 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1168 {
1169         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1170
1171         if (pc == NULL) {
1172                 ERR("invalid parameter");
1173                 return PKGMGR_R_EINVAL;
1174         }
1175
1176         client->status_type = status_type;
1177
1178         return PKGMGR_R_OK;
1179 }
1180
1181 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1182                 void *data)
1183 {
1184         int ret;
1185         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1186         struct cb_info *cb_info;
1187
1188         if (pc == NULL || event_cb == NULL) {
1189                 ERR("invalid parameter");
1190                 return PKGMGR_R_EINVAL;
1191         }
1192
1193         if (client->pc_type != PC_LISTENING) {
1194                 ERR("client->pc_type is not PC_LISTENING");
1195                 return PKGMGR_R_EINVAL;
1196         }
1197
1198         cb_info = __create_event_cb_info(client, event_cb, data, NULL);
1199         if (cb_info == NULL)
1200                 return PKGMGR_R_ENOMEM;
1201         cb_info->status_type = client->status_type;
1202         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1203         if (ret != PKGMGR_R_OK) {
1204                 __free_cb_info(cb_info);
1205                 return ret;
1206         }
1207         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1208
1209         return cb_info->req_id;
1210 }
1211
1212 API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
1213                 pkgmgr_app_handler app_event_cb, void *data)
1214 {
1215         int ret;
1216         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1217         struct cb_info *cb_info;
1218
1219         if (pc == NULL || app_event_cb == NULL) {
1220                 ERR("invalid parameter");
1221                 return PKGMGR_R_EINVAL;
1222         }
1223
1224         if (client->pc_type != PC_LISTENING) {
1225                 ERR("client->pc_type is not PC_LISTENING");
1226                 return PKGMGR_R_EINVAL;
1227         }
1228
1229         cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL);
1230         if (cb_info == NULL)
1231                 return PKGMGR_R_ENOMEM;
1232         cb_info->status_type = client->status_type;
1233         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1234         if (ret != PKGMGR_R_OK) {
1235                 __free_cb_info(cb_info);
1236                 return ret;
1237         }
1238         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1239
1240         return cb_info->req_id;
1241 }
1242
1243 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
1244 {
1245         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1246         GList *tmp;
1247         GList *next;
1248         struct cb_info *cb_info;
1249
1250         if (pc == NULL) {
1251                 ERR("invalid parameter");
1252                 return PKGMGR_R_EINVAL;
1253         }
1254
1255         /* unset all callback */
1256         tmp = client->cb_info_list;
1257         while (tmp != NULL) {
1258                 next = tmp->next;
1259                 cb_info = (struct cb_info *)tmp->data;
1260                 pkgmgr_client_connection_unset_callback(pc, cb_info);
1261                 client->cb_info_list = g_list_delete_link(client->cb_info_list,
1262                                 tmp);
1263                 __free_cb_info(cb_info);
1264                 tmp = next;
1265         }
1266
1267         return PKGMGR_R_OK;
1268 }
1269
1270 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1271                 const char *pkgid, const char *key, const char *val)
1272 {
1273         /* client cannot broadcast signal */
1274         return PKGMGR_R_OK;
1275 }
1276
1277 /* TODO: deprecate(or remove) */
1278 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
1279                 int service_mode, pkgmgr_client *pc, const char *pkg_type,
1280                 const char *pkgid, const char *custom_info,
1281                 pkgmgr_handler event_cb, void *data)
1282 {
1283         return pkgmgr_client_usr_request_service(service_type, service_mode,
1284                         pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
1285                         data);
1286 }
1287
1288 API int pkgmgr_client_usr_request_service(
1289                 pkgmgr_request_service_type service_type, int service_mode,
1290                 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
1291                 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
1292                 void *data)
1293 {
1294         int ret = 0;
1295
1296         /* Check for NULL value of service type */
1297         retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1298         retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1299
1300         switch (service_type) {
1301         case PM_REQUEST_MOVE:
1302                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1303                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1304                 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1305
1306                 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1307                 break;
1308
1309         case PM_REQUEST_GET_SIZE:
1310                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1311                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1312                 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1313
1314                 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1315                 break;
1316
1317         case PM_REQUEST_KILL_APP:
1318         case PM_REQUEST_CHECK_APP:
1319                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1320                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1321
1322                 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1323                 if (ret < 0)
1324                         ERR("__check_app_process fail \n");
1325                 else
1326                         ret = PKGMGR_R_OK;
1327
1328                 break;
1329
1330         default:
1331                 ERR("Wrong Request\n");
1332                 ret = -1;
1333                 break;
1334         }
1335
1336 catch:
1337
1338         return ret;
1339 }
1340
1341
1342 API int pkgmgr_client_usr_request_size_info(uid_t uid)
1343 {
1344         int ret;
1345         struct pkgmgr_client *client;
1346
1347         client = pkgmgr_client_new(PC_REQUEST);
1348         if (client == NULL) {
1349                 ERR("out of memory");
1350                 return PKGMGR_R_ENOMEM;
1351         }
1352
1353         ret = __request_size_info(client, uid);
1354         if (ret < 0)
1355                 ERR("__request_size_info fail");
1356
1357         pkgmgr_client_free(client);
1358         return ret;
1359 }
1360
1361 API int pkgmgr_client_request_size_info(void)
1362 {
1363         /* get all package size (data, total) */
1364         return pkgmgr_client_usr_request_size_info(_getuid());
1365 }
1366
1367 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1368 {
1369         GVariant *result;
1370         int ret;
1371         struct pkgmgr_client_t *client;
1372
1373         if (pkgid == NULL) {
1374                 ERR("invalid parameter");
1375                 return PKGMGR_R_EINVAL;
1376         }
1377
1378         client = pkgmgr_client_new(PC_REQUEST);
1379         if (client == NULL) {
1380                 ERR("out of memory");
1381                 return PKGMGR_R_ENOMEM;
1382         }
1383
1384         ret = pkgmgr_client_connection_send_request(client, "clearcache",
1385                         g_variant_new("(us)", uid, pkgid), &result);
1386         if (ret != PKGMGR_R_OK) {
1387                 ERR("request failed: %d", ret);
1388                 return ret;
1389         }
1390
1391         g_variant_get(result, "(i)", &ret);
1392         g_variant_unref(result);
1393
1394         return ret;
1395 }
1396
1397 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1398 {
1399         return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
1400 }
1401
1402 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1403 {
1404         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1405 }
1406
1407 API int pkgmgr_client_clear_all_cache_dir(void)
1408 {
1409         return pkgmgr_client_usr_clear_cache_dir(
1410                         PKG_CLEAR_ALL_CACHE, getuid());
1411 }
1412
1413 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
1414                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1415                 void *data)
1416 {
1417         return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
1418                         _getuid());
1419 }
1420
1421 /* TODO: deprecate(or remove) */
1422 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
1423                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1424                 void *data, uid_t uid)
1425 {
1426         GVariant *result;
1427         int ret = PKGMGR_R_ECOMM;
1428         char *req_key = NULL;
1429         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1430         struct cb_info *cb_info;
1431
1432         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1433                 ERR("invalid parameter");
1434                 return PKGMGR_R_EINVAL;
1435         }
1436
1437         if (client->pc_type != PC_REQUEST) {
1438                 ERR("client->pc_type is not PC_REQUEST");
1439                 return PKGMGR_R_EINVAL;
1440         }
1441
1442         /* FIXME */
1443         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1444                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1445         else
1446                 get_type = PM_GET_PKG_SIZE_INFO;
1447
1448         ret = pkgmgr_client_connection_send_request(client, "getsize",
1449                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
1450         if (ret != PKGMGR_R_OK) {
1451                 ERR("request failed: %d", ret);
1452                 return ret;
1453         }
1454
1455         g_variant_get(result, "(i&s)", &ret, &req_key);
1456         if (req_key == NULL) {
1457                 g_variant_unref(result);
1458                 return PKGMGR_R_ECOMM;
1459         }
1460         if (ret != PKGMGR_R_OK) {
1461                 g_variant_unref(result);
1462                 return ret;
1463         }
1464
1465         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1466         if (cb_info == NULL) {
1467                 g_variant_unref(result);
1468                 return PKGMGR_R_ENOMEM;
1469         }
1470         g_variant_unref(result);
1471         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1472         if (ret != PKGMGR_R_OK) {
1473                 __free_cb_info(cb_info);
1474                 return ret;
1475         }
1476         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1477
1478         return PKGMGR_R_OK;
1479 }
1480
1481 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
1482                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1483                 void *user_data, uid_t uid)
1484 {
1485         GVariant *result;
1486         int ret = PKGMGR_R_ECOMM;
1487         char *req_key = NULL;
1488         int get_type;
1489         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1490         struct cb_info *cb_info;
1491
1492         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1493                 ERR("invalid parameter");
1494                 return PKGMGR_R_EINVAL;
1495         }
1496
1497         if (client->pc_type != PC_REQUEST) {
1498                 ERR("client->pc_type is not PC_REQUEST");
1499                 return PKGMGR_R_EINVAL;
1500         }
1501
1502         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1503                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1504         else
1505                 get_type = PM_GET_PKG_SIZE_INFO;
1506
1507         ret = pkgmgr_client_connection_send_request(client, "getsize",
1508                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
1509         if (ret != PKGMGR_R_OK) {
1510                 ERR("request failed: %d", ret);
1511                 return ret;
1512         }
1513
1514         g_variant_get(result, "(i&s)", &ret, &req_key);
1515         if (req_key == NULL) {
1516                 g_variant_unref(result);
1517                 return PKGMGR_R_ECOMM;
1518         }
1519         if (ret != PKGMGR_R_OK) {
1520                 g_variant_unref(result);
1521                 return ret;
1522         }
1523
1524         cb_info = __create_size_info_cb_info(client, event_cb, user_data,
1525                         req_key);
1526         if (cb_info == NULL) {
1527                 g_variant_unref(result);
1528                 return PKGMGR_R_ENOMEM;
1529         }
1530         g_variant_unref(result);
1531         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1532         if (ret != PKGMGR_R_OK) {
1533                 __free_cb_info(cb_info);
1534                 return ret;
1535         }
1536         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1537
1538         return PKGMGR_R_OK;
1539 }
1540
1541 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
1542                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1543                 void *user_data)
1544 {
1545         return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
1546                         user_data, _getuid());
1547 }
1548
1549 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
1550                 pkgmgr_total_pkg_size_info_receive_cb event_cb,
1551                 void *user_data, uid_t uid)
1552 {       /* total package size info */
1553         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1554                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
1555                         user_data, uid);
1556 }
1557
1558 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
1559                 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
1560 {
1561         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1562                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
1563                         user_data, _getuid());
1564 }
1565
1566 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
1567                 const char *resp_data, char **req_data, char **license_url)
1568 {
1569         GVariant *result;
1570         int ret;
1571         char *data;
1572         char *url;
1573         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1574
1575         if (pc == NULL || resp_data == NULL || req_data == NULL ||
1576                         license_url == NULL) {
1577                 ERR("invalid parameter");
1578                 return PKGMGR_R_EINVAL;
1579         }
1580
1581         if (client->pc_type != PC_REQUEST) {
1582                 ERR("client->pc_type is not PC_REQUEST");
1583                 return PKGMGR_R_EINVAL;
1584         }
1585
1586         ret = pkgmgr_client_connection_send_request(client,
1587                         "generate_license_request",
1588                         g_variant_new("(s)", resp_data), &result);
1589         if (ret != PKGMGR_R_OK) {
1590                 ERR("request failed: %d", ret);
1591                 return ret;
1592         }
1593
1594         g_variant_get(result, "(i&s&s)", &ret, &data, &url);
1595         if (ret != PKGMGR_R_OK) {
1596                 ERR("generate_license_request failed: %d", ret);
1597                 g_variant_unref(result);
1598                 return ret;
1599         }
1600
1601         *req_data = strdup(data);
1602         *license_url = strdup(url);
1603
1604         g_variant_unref(result);
1605
1606         return PKGMGR_R_OK;
1607 }
1608
1609 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
1610 {
1611         GVariant *result;
1612         int ret;
1613         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1614
1615         if (pc == NULL || resp_data == NULL) {
1616                 ERR("invalid parameter");
1617                 return PKGMGR_R_EINVAL;
1618         }
1619
1620         if (client->pc_type != PC_REQUEST) {
1621                 ERR("client->pc_type is not PC_REQUEST");
1622                 return PKGMGR_R_EINVAL;
1623         }
1624
1625         ret = pkgmgr_client_connection_send_request(client, "register_license",
1626                         g_variant_new("(s)", resp_data), &result);
1627         if (ret != PKGMGR_R_OK) {
1628                 ERR("request failed: %d", ret);
1629                 return ret;
1630         }
1631
1632         g_variant_get(result, "(i)", &ret);
1633         g_variant_unref(result);
1634         if (ret != PKGMGR_R_OK)
1635                 ERR("register license failed: %d", ret);
1636
1637         return ret;
1638 }
1639
1640 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
1641                 const char *drm_file_path, const char *decrypted_file_path)
1642 {
1643         GVariant *result;
1644         int ret;
1645         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1646
1647         if (pc == NULL || drm_file_path == NULL ||
1648                         decrypted_file_path == NULL) {
1649                 ERR("invalid parameter");
1650                 return PKGMGR_R_EINVAL;
1651         }
1652
1653         if (client->pc_type != PC_REQUEST) {
1654                 ERR("client->pc_type is not PC_REQUEST");
1655                 return PKGMGR_R_EINVAL;
1656         }
1657
1658         ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
1659                         g_variant_new("(ss)", drm_file_path,
1660                                 decrypted_file_path), &result);
1661         if (ret != PKGMGR_R_OK) {
1662                 ERR("request failed: %d", ret);
1663                 return ret;
1664         }
1665
1666         g_variant_get(result, "(i)", &ret);
1667         g_variant_unref(result);
1668         if (ret != PKGMGR_R_OK)
1669                 ERR("decrypt_package failed: %d", ret);
1670
1671         return ret;
1672 }
1673
1674 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
1675 {
1676         return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
1677 }
1678
1679 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
1680                 const char *appid, uid_t uid)
1681 {
1682         int ret;
1683         GVariant *result;
1684         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1685
1686         if (pc == NULL || appid == NULL) {
1687                 ERR("Invalid parameter");
1688                 return PKGMGR_R_EINVAL;
1689         }
1690
1691         ret = pkgmgr_client_connection_send_request(client,
1692                         "enable_app_splash_screen",
1693                         g_variant_new("(us)", uid, appid), &result);
1694         if (ret != PKGMGR_R_OK) {
1695                 ERR("request failed: %d", ret);
1696                 return ret;
1697         }
1698
1699         g_variant_get(result, "(i)", &ret);
1700         g_variant_unref(result);
1701         if (ret != PKGMGR_R_OK)
1702                 ERR("enable splash screen failed: %d", ret);
1703
1704         return ret;
1705 }
1706
1707 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
1708                 const char *appid)
1709 {
1710         return pkgmgr_client_usr_disable_splash_screen(pc, appid,
1711                         _getuid());
1712 }
1713
1714 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
1715                 const char *appid, uid_t uid)
1716 {
1717         int ret;
1718         GVariant *result;
1719         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1720
1721         if (pc == NULL || appid == NULL) {
1722                 ERR("Invalid parameter");
1723                 return PKGMGR_R_EINVAL;
1724         }
1725
1726         ret = pkgmgr_client_connection_send_request(client,
1727                         "disable_app_splash_screen",
1728                         g_variant_new("(us)", uid, appid), &result);
1729         if (ret != PKGMGR_R_OK) {
1730                 ERR("request failed: %d", ret);
1731                 return ret;
1732         }
1733
1734         g_variant_get(result, "(i)", &ret);
1735         g_variant_unref(result);
1736         if (ret != PKGMGR_R_OK)
1737                 ERR("disable splash screen failed: %d", ret);
1738
1739         return ret;
1740 }
1741
1742 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1743                 int mode, uid_t uid)
1744 {
1745         GVariant *result;
1746         int ret = PKGMGR_R_ECOMM;
1747         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1748
1749         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1750                 ERR("invalid parameter");
1751                 return PKGMGR_R_EINVAL;
1752         }
1753
1754         ret = pkgmgr_client_connection_send_request(client,
1755                         "set_restriction_mode",
1756                         g_variant_new("(usi)", uid, pkgid, mode), &result);
1757         if (ret != PKGMGR_R_OK) {
1758                 ERR("request failed: %d", ret);
1759                 return ret;
1760         }
1761
1762         g_variant_get(result, "(i)", &ret);
1763         g_variant_unref(result);
1764
1765         return ret;
1766 }
1767
1768 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
1769                 const char *pkgid, int mode, uid_t uid)
1770 {
1771         return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
1772 }
1773
1774 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
1775                 const char *pkgid, int mode)
1776 {
1777         return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
1778                         _getuid());
1779 }
1780
1781 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1782                 int mode, uid_t uid)
1783 {
1784         GVariant *result;
1785         int ret = PKGMGR_R_ECOMM;
1786         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1787
1788         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1789                 ERR("invalid parameter");
1790                 return PKGMGR_R_EINVAL;
1791         }
1792
1793         ret = pkgmgr_client_connection_send_request(client,
1794                         "unset_restriction_mode",
1795                         g_variant_new("(usi)", uid, pkgid, mode), &result);
1796         if (ret != PKGMGR_R_OK) {
1797                 ERR("request failed: %d", ret);
1798                 return ret;
1799         }
1800
1801         g_variant_get(result, "(i)", &ret);
1802         g_variant_unref(result);
1803
1804         return ret;
1805
1806 }
1807
1808 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
1809                 const char *pkgid, int mode, uid_t uid)
1810 {
1811         return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
1812 }
1813
1814 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
1815                 const char *pkgid, int mode)
1816 {
1817         return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
1818                         _getuid());
1819 }
1820
1821 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1822                 int *mode, uid_t uid)
1823 {
1824         GVariant *result;
1825         int ret = PKGMGR_R_ECOMM;
1826         gint m;
1827         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1828
1829         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
1830                 ERR("invalid parameter");
1831                 return PKGMGR_R_EINVAL;
1832         }
1833
1834         ret = pkgmgr_client_connection_send_request(client,
1835                         "get_restriction_mode",
1836                         g_variant_new("(us)", uid, pkgid), &result);
1837         if (ret != PKGMGR_R_OK) {
1838                 ERR("request failed: %d", ret);
1839                 return ret;
1840         }
1841
1842         g_variant_get(result, "(ii)", &m, &ret);
1843         g_variant_unref(result);
1844         if (ret != PKGMGR_R_OK)
1845                 return ret;
1846
1847         *mode = m;
1848
1849         return PKGMGR_R_OK;
1850 }
1851
1852 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
1853                 const char *pkgid, int *mode, uid_t uid)
1854 {
1855         return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
1856 }
1857
1858 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
1859                 const char *pkgid, int *mode)
1860 {
1861         return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
1862                         _getuid());
1863 }
1864
1865 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
1866                 uid_t uid)
1867 {
1868         GVariant *result;
1869         int ret = PKGMGR_R_ECOMM;
1870         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1871
1872         if (pc == NULL) {
1873                 ERR("invalid parameter");
1874                 return PKGMGR_R_EINVAL;
1875         }
1876
1877         ret = pkgmgr_client_connection_send_request(client,
1878                         "set_restriction_mode",
1879                         g_variant_new("(usi)", uid, "", mode), &result);
1880         if (ret != PKGMGR_R_OK) {
1881                 ERR("request failed: %d", ret);
1882                 return ret;
1883         }
1884
1885         g_variant_get(result, "(i)", &ret);
1886         g_variant_unref(result);
1887
1888         return ret;
1889 }
1890
1891 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
1892 {
1893         return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
1894 }
1895
1896 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
1897                 uid_t uid)
1898 {
1899         GVariant *result;
1900         int ret = PKGMGR_R_ECOMM;
1901         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1902
1903         if (pc == NULL) {
1904                 ERR("invalid parameter");
1905                 return PKGMGR_R_EINVAL;
1906         }
1907
1908         ret = pkgmgr_client_connection_send_request(client,
1909                         "unset_restriction_mode",
1910                         g_variant_new("(usi)", uid, "", mode), &result);
1911         if (ret != PKGMGR_R_OK) {
1912                 ERR("request failed: %d", ret);
1913                 return ret;
1914         }
1915
1916         g_variant_get(result, "(i)", &ret);
1917         g_variant_unref(result);
1918
1919         return ret;
1920 }
1921
1922 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
1923 {
1924         return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
1925 }
1926
1927 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
1928                 int *mode, uid_t uid)
1929 {
1930         GVariant *result;
1931         int ret = PKGMGR_R_ECOMM;
1932         gint m;
1933         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1934
1935         if (pc == NULL) {
1936                 ERR("invalid parameter");
1937                 return PKGMGR_R_EINVAL;
1938         }
1939
1940         ret = pkgmgr_client_connection_send_request(client,
1941                         "get_restriction_mode",
1942                         g_variant_new("(us)", uid, ""), &result);
1943         if (ret != PKGMGR_R_OK) {
1944                 ERR("request failed: %d", ret);
1945                 return ret;
1946         }
1947
1948         g_variant_get(result, "(ii)", &m, &ret);
1949         g_variant_unref(result);
1950         if (ret != PKGMGR_R_OK)
1951                 return ret;
1952
1953         *mode = m;
1954
1955         return PKGMGR_R_OK;
1956 }
1957
1958 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
1959 {
1960         return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
1961 }