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                 tmp = next;
1264         }
1265
1266         return PKGMGR_R_OK;
1267 }
1268
1269 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1270                 const char *pkgid, const char *key, const char *val)
1271 {
1272         /* client cannot broadcast signal */
1273         return PKGMGR_R_OK;
1274 }
1275
1276 /* TODO: deprecate(or remove) */
1277 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
1278                 int service_mode, pkgmgr_client *pc, const char *pkg_type,
1279                 const char *pkgid, const char *custom_info,
1280                 pkgmgr_handler event_cb, void *data)
1281 {
1282         return pkgmgr_client_usr_request_service(service_type, service_mode,
1283                         pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
1284                         data);
1285 }
1286
1287 API int pkgmgr_client_usr_request_service(
1288                 pkgmgr_request_service_type service_type, int service_mode,
1289                 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
1290                 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
1291                 void *data)
1292 {
1293         int ret = 0;
1294
1295         /* Check for NULL value of service type */
1296         retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1297         retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1298
1299         switch (service_type) {
1300         case PM_REQUEST_MOVE:
1301                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1302                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1303                 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1304
1305                 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1306                 break;
1307
1308         case PM_REQUEST_GET_SIZE:
1309                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1310                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1311                 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1312
1313                 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1314                 break;
1315
1316         case PM_REQUEST_KILL_APP:
1317         case PM_REQUEST_CHECK_APP:
1318                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1319                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1320
1321                 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1322                 if (ret < 0)
1323                         ERR("__check_app_process fail \n");
1324                 else
1325                         ret = PKGMGR_R_OK;
1326
1327                 break;
1328
1329         default:
1330                 ERR("Wrong Request\n");
1331                 ret = -1;
1332                 break;
1333         }
1334
1335 catch:
1336
1337         return ret;
1338 }
1339
1340
1341 API int pkgmgr_client_usr_request_size_info(uid_t uid)
1342 {
1343         int ret;
1344         struct pkgmgr_client *client;
1345
1346         client = pkgmgr_client_new(PC_REQUEST);
1347         if (client == NULL) {
1348                 ERR("out of memory");
1349                 return PKGMGR_R_ENOMEM;
1350         }
1351
1352         ret = __request_size_info(client, uid);
1353         if (ret < 0)
1354                 ERR("__request_size_info fail");
1355
1356         pkgmgr_client_free(client);
1357         return ret;
1358 }
1359
1360 API int pkgmgr_client_request_size_info(void)
1361 {
1362         /* get all package size (data, total) */
1363         return pkgmgr_client_usr_request_size_info(_getuid());
1364 }
1365
1366 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1367 {
1368         GVariant *result;
1369         int ret;
1370         struct pkgmgr_client_t *client;
1371
1372         if (pkgid == NULL) {
1373                 ERR("invalid parameter");
1374                 return PKGMGR_R_EINVAL;
1375         }
1376
1377         client = pkgmgr_client_new(PC_REQUEST);
1378         if (client == NULL) {
1379                 ERR("out of memory");
1380                 return PKGMGR_R_ENOMEM;
1381         }
1382
1383         ret = pkgmgr_client_connection_send_request(client, "clearcache",
1384                         g_variant_new("(us)", uid, pkgid), &result);
1385         if (ret != PKGMGR_R_OK) {
1386                 ERR("request failed: %d", ret);
1387                 return ret;
1388         }
1389
1390         g_variant_get(result, "(i)", &ret);
1391         g_variant_unref(result);
1392
1393         return ret;
1394 }
1395
1396 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1397 {
1398         return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
1399 }
1400
1401 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1402 {
1403         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1404 }
1405
1406 API int pkgmgr_client_clear_all_cache_dir(void)
1407 {
1408         return pkgmgr_client_usr_clear_cache_dir(
1409                         PKG_CLEAR_ALL_CACHE, getuid());
1410 }
1411
1412 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
1413                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1414                 void *data)
1415 {
1416         return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
1417                         _getuid());
1418 }
1419
1420 /* TODO: deprecate(or remove) */
1421 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
1422                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1423                 void *data, uid_t uid)
1424 {
1425         GVariant *result;
1426         int ret = PKGMGR_R_ECOMM;
1427         char *req_key = NULL;
1428         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1429         struct cb_info *cb_info;
1430
1431         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1432                 ERR("invalid parameter");
1433                 return PKGMGR_R_EINVAL;
1434         }
1435
1436         if (client->pc_type != PC_REQUEST) {
1437                 ERR("client->pc_type is not PC_REQUEST");
1438                 return PKGMGR_R_EINVAL;
1439         }
1440
1441         /* FIXME */
1442         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1443                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1444         else
1445                 get_type = PM_GET_PKG_SIZE_INFO;
1446
1447         ret = pkgmgr_client_connection_send_request(client, "getsize",
1448                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
1449         if (ret != PKGMGR_R_OK) {
1450                 ERR("request failed: %d", ret);
1451                 return ret;
1452         }
1453
1454         g_variant_get(result, "(i&s)", &ret, &req_key);
1455         if (req_key == NULL) {
1456                 g_variant_unref(result);
1457                 return PKGMGR_R_ECOMM;
1458         }
1459         if (ret != PKGMGR_R_OK) {
1460                 g_variant_unref(result);
1461                 return ret;
1462         }
1463
1464         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1465         if (cb_info == NULL) {
1466                 g_variant_unref(result);
1467                 return PKGMGR_R_ENOMEM;
1468         }
1469         g_variant_unref(result);
1470         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1471         if (ret != PKGMGR_R_OK) {
1472                 __free_cb_info(cb_info);
1473                 return ret;
1474         }
1475         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1476
1477         return PKGMGR_R_OK;
1478 }
1479
1480 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
1481                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1482                 void *user_data, uid_t uid)
1483 {
1484         GVariant *result;
1485         int ret = PKGMGR_R_ECOMM;
1486         char *req_key = NULL;
1487         int get_type;
1488         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1489         struct cb_info *cb_info;
1490
1491         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1492                 ERR("invalid parameter");
1493                 return PKGMGR_R_EINVAL;
1494         }
1495
1496         if (client->pc_type != PC_REQUEST) {
1497                 ERR("client->pc_type is not PC_REQUEST");
1498                 return PKGMGR_R_EINVAL;
1499         }
1500
1501         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1502                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1503         else
1504                 get_type = PM_GET_PKG_SIZE_INFO;
1505
1506         ret = pkgmgr_client_connection_send_request(client, "getsize",
1507                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
1508         if (ret != PKGMGR_R_OK) {
1509                 ERR("request failed: %d", ret);
1510                 return ret;
1511         }
1512
1513         g_variant_get(result, "(i&s)", &ret, &req_key);
1514         if (req_key == NULL) {
1515                 g_variant_unref(result);
1516                 return PKGMGR_R_ECOMM;
1517         }
1518         if (ret != PKGMGR_R_OK) {
1519                 g_variant_unref(result);
1520                 return ret;
1521         }
1522
1523         cb_info = __create_size_info_cb_info(client, event_cb, user_data,
1524                         req_key);
1525         if (cb_info == NULL) {
1526                 g_variant_unref(result);
1527                 return PKGMGR_R_ENOMEM;
1528         }
1529         g_variant_unref(result);
1530         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1531         if (ret != PKGMGR_R_OK) {
1532                 __free_cb_info(cb_info);
1533                 return ret;
1534         }
1535         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1536
1537         return PKGMGR_R_OK;
1538 }
1539
1540 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
1541                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1542                 void *user_data)
1543 {
1544         return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
1545                         user_data, _getuid());
1546 }
1547
1548 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
1549                 pkgmgr_total_pkg_size_info_receive_cb event_cb,
1550                 void *user_data, uid_t uid)
1551 {       /* total package size info */
1552         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1553                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
1554                         user_data, uid);
1555 }
1556
1557 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
1558                 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
1559 {
1560         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1561                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
1562                         user_data, _getuid());
1563 }
1564
1565 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
1566                 const char *resp_data, char **req_data, char **license_url)
1567 {
1568         GVariant *result;
1569         int ret;
1570         char *data;
1571         char *url;
1572         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1573
1574         if (pc == NULL || resp_data == NULL || req_data == NULL ||
1575                         license_url == NULL) {
1576                 ERR("invalid parameter");
1577                 return PKGMGR_R_EINVAL;
1578         }
1579
1580         if (client->pc_type != PC_REQUEST) {
1581                 ERR("client->pc_type is not PC_REQUEST");
1582                 return PKGMGR_R_EINVAL;
1583         }
1584
1585         ret = pkgmgr_client_connection_send_request(client,
1586                         "generate_license_request",
1587                         g_variant_new("(s)", resp_data), &result);
1588         if (ret != PKGMGR_R_OK) {
1589                 ERR("request failed: %d", ret);
1590                 return ret;
1591         }
1592
1593         g_variant_get(result, "(i&s&s)", &ret, &data, &url);
1594         if (ret != PKGMGR_R_OK) {
1595                 ERR("generate_license_request failed: %d", ret);
1596                 g_variant_unref(result);
1597                 return ret;
1598         }
1599
1600         *req_data = strdup(data);
1601         *license_url = strdup(url);
1602
1603         g_variant_unref(result);
1604
1605         return PKGMGR_R_OK;
1606 }
1607
1608 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
1609 {
1610         GVariant *result;
1611         int ret;
1612         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1613
1614         if (pc == NULL || resp_data == NULL) {
1615                 ERR("invalid parameter");
1616                 return PKGMGR_R_EINVAL;
1617         }
1618
1619         if (client->pc_type != PC_REQUEST) {
1620                 ERR("client->pc_type is not PC_REQUEST");
1621                 return PKGMGR_R_EINVAL;
1622         }
1623
1624         ret = pkgmgr_client_connection_send_request(client, "register_license",
1625                         g_variant_new("(s)", resp_data), &result);
1626         if (ret != PKGMGR_R_OK) {
1627                 ERR("request failed: %d", ret);
1628                 return ret;
1629         }
1630
1631         g_variant_get(result, "(i)", &ret);
1632         g_variant_unref(result);
1633         if (ret != PKGMGR_R_OK)
1634                 ERR("register license failed: %d", ret);
1635
1636         return ret;
1637 }
1638
1639 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
1640                 const char *drm_file_path, const char *decrypted_file_path)
1641 {
1642         GVariant *result;
1643         int ret;
1644         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1645
1646         if (pc == NULL || drm_file_path == NULL ||
1647                         decrypted_file_path == NULL) {
1648                 ERR("invalid parameter");
1649                 return PKGMGR_R_EINVAL;
1650         }
1651
1652         if (client->pc_type != PC_REQUEST) {
1653                 ERR("client->pc_type is not PC_REQUEST");
1654                 return PKGMGR_R_EINVAL;
1655         }
1656
1657         ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
1658                         g_variant_new("(ss)", drm_file_path,
1659                                 decrypted_file_path), &result);
1660         if (ret != PKGMGR_R_OK) {
1661                 ERR("request failed: %d", ret);
1662                 return ret;
1663         }
1664
1665         g_variant_get(result, "(i)", &ret);
1666         g_variant_unref(result);
1667         if (ret != PKGMGR_R_OK)
1668                 ERR("decrypt_package failed: %d", ret);
1669
1670         return ret;
1671 }
1672
1673 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
1674 {
1675         return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
1676 }
1677
1678 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
1679                 const char *appid, uid_t uid)
1680 {
1681         int ret;
1682         GVariant *result;
1683         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1684
1685         if (pc == NULL || appid == NULL) {
1686                 ERR("Invalid parameter");
1687                 return PKGMGR_R_EINVAL;
1688         }
1689
1690         ret = pkgmgr_client_connection_send_request(client,
1691                         "enable_app_splash_screen",
1692                         g_variant_new("(us)", uid, appid), &result);
1693         if (ret != PKGMGR_R_OK) {
1694                 ERR("request failed: %d", ret);
1695                 return ret;
1696         }
1697
1698         g_variant_get(result, "(i)", &ret);
1699         g_variant_unref(result);
1700         if (ret != PKGMGR_R_OK)
1701                 ERR("enable splash screen failed: %d", ret);
1702
1703         return ret;
1704 }
1705
1706 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
1707                 const char *appid)
1708 {
1709         return pkgmgr_client_usr_disable_splash_screen(pc, appid,
1710                         _getuid());
1711 }
1712
1713 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
1714                 const char *appid, uid_t uid)
1715 {
1716         int ret;
1717         GVariant *result;
1718         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1719
1720         if (pc == NULL || appid == NULL) {
1721                 ERR("Invalid parameter");
1722                 return PKGMGR_R_EINVAL;
1723         }
1724
1725         ret = pkgmgr_client_connection_send_request(client,
1726                         "disable_app_splash_screen",
1727                         g_variant_new("(us)", uid, appid), &result);
1728         if (ret != PKGMGR_R_OK) {
1729                 ERR("request failed: %d", ret);
1730                 return ret;
1731         }
1732
1733         g_variant_get(result, "(i)", &ret);
1734         g_variant_unref(result);
1735         if (ret != PKGMGR_R_OK)
1736                 ERR("disable splash screen failed: %d", ret);
1737
1738         return ret;
1739 }
1740
1741 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1742                 int mode, uid_t uid)
1743 {
1744         GVariant *result;
1745         int ret = PKGMGR_R_ECOMM;
1746         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1747
1748         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1749                 ERR("invalid parameter");
1750                 return PKGMGR_R_EINVAL;
1751         }
1752
1753         ret = pkgmgr_client_connection_send_request(client,
1754                         "set_restriction_mode",
1755                         g_variant_new("(usi)", uid, pkgid, mode), &result);
1756         if (ret != PKGMGR_R_OK) {
1757                 ERR("request failed: %d", ret);
1758                 return ret;
1759         }
1760
1761         g_variant_get(result, "(i)", &ret);
1762         g_variant_unref(result);
1763
1764         return ret;
1765 }
1766
1767 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
1768                 const char *pkgid, int mode, uid_t uid)
1769 {
1770         return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
1771 }
1772
1773 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
1774                 const char *pkgid, int mode)
1775 {
1776         return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
1777                         _getuid());
1778 }
1779
1780 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1781                 int mode, uid_t uid)
1782 {
1783         GVariant *result;
1784         int ret = PKGMGR_R_ECOMM;
1785         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1786
1787         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1788                 ERR("invalid parameter");
1789                 return PKGMGR_R_EINVAL;
1790         }
1791
1792         ret = pkgmgr_client_connection_send_request(client,
1793                         "unset_restriction_mode",
1794                         g_variant_new("(usi)", uid, pkgid, mode), &result);
1795         if (ret != PKGMGR_R_OK) {
1796                 ERR("request failed: %d", ret);
1797                 return ret;
1798         }
1799
1800         g_variant_get(result, "(i)", &ret);
1801         g_variant_unref(result);
1802
1803         return ret;
1804
1805 }
1806
1807 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
1808                 const char *pkgid, int mode, uid_t uid)
1809 {
1810         return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
1811 }
1812
1813 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
1814                 const char *pkgid, int mode)
1815 {
1816         return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
1817                         _getuid());
1818 }
1819
1820 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1821                 int *mode, uid_t uid)
1822 {
1823         GVariant *result;
1824         int ret = PKGMGR_R_ECOMM;
1825         gint m;
1826         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1827
1828         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
1829                 ERR("invalid parameter");
1830                 return PKGMGR_R_EINVAL;
1831         }
1832
1833         ret = pkgmgr_client_connection_send_request(client,
1834                         "get_restriction_mode",
1835                         g_variant_new("(us)", uid, pkgid), &result);
1836         if (ret != PKGMGR_R_OK) {
1837                 ERR("request failed: %d", ret);
1838                 return ret;
1839         }
1840
1841         g_variant_get(result, "(ii)", &m, &ret);
1842         g_variant_unref(result);
1843         if (ret != PKGMGR_R_OK)
1844                 return ret;
1845
1846         *mode = m;
1847
1848         return PKGMGR_R_OK;
1849 }
1850
1851 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
1852                 const char *pkgid, int *mode, uid_t uid)
1853 {
1854         return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
1855 }
1856
1857 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
1858                 const char *pkgid, int *mode)
1859 {
1860         return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
1861                         _getuid());
1862 }
1863
1864 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
1865                 uid_t uid)
1866 {
1867         GVariant *result;
1868         int ret = PKGMGR_R_ECOMM;
1869         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1870
1871         if (pc == NULL) {
1872                 ERR("invalid parameter");
1873                 return PKGMGR_R_EINVAL;
1874         }
1875
1876         ret = pkgmgr_client_connection_send_request(client,
1877                         "set_restriction_mode",
1878                         g_variant_new("(usi)", uid, "", mode), &result);
1879         if (ret != PKGMGR_R_OK) {
1880                 ERR("request failed: %d", ret);
1881                 return ret;
1882         }
1883
1884         g_variant_get(result, "(i)", &ret);
1885         g_variant_unref(result);
1886
1887         return ret;
1888 }
1889
1890 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
1891 {
1892         return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
1893 }
1894
1895 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
1896                 uid_t uid)
1897 {
1898         GVariant *result;
1899         int ret = PKGMGR_R_ECOMM;
1900         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1901
1902         if (pc == NULL) {
1903                 ERR("invalid parameter");
1904                 return PKGMGR_R_EINVAL;
1905         }
1906
1907         ret = pkgmgr_client_connection_send_request(client,
1908                         "unset_restriction_mode",
1909                         g_variant_new("(usi)", uid, "", mode), &result);
1910         if (ret != PKGMGR_R_OK) {
1911                 ERR("request failed: %d", ret);
1912                 return ret;
1913         }
1914
1915         g_variant_get(result, "(i)", &ret);
1916         g_variant_unref(result);
1917
1918         return ret;
1919 }
1920
1921 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
1922 {
1923         return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
1924 }
1925
1926 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
1927                 int *mode, uid_t uid)
1928 {
1929         GVariant *result;
1930         int ret = PKGMGR_R_ECOMM;
1931         gint m;
1932         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1933
1934         if (pc == NULL) {
1935                 ERR("invalid parameter");
1936                 return PKGMGR_R_EINVAL;
1937         }
1938
1939         ret = pkgmgr_client_connection_send_request(client,
1940                         "get_restriction_mode",
1941                         g_variant_new("(us)", uid, ""), &result);
1942         if (ret != PKGMGR_R_OK) {
1943                 ERR("request failed: %d", ret);
1944                 return ret;
1945         }
1946
1947         g_variant_get(result, "(ii)", &m, &ret);
1948         g_variant_unref(result);
1949         if (ret != PKGMGR_R_OK)
1950                 return ret;
1951
1952         *mode = m;
1953
1954         return PKGMGR_R_OK;
1955 }
1956
1957 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
1958 {
1959         return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
1960 }