client/src/pkgmgr.c

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