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