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