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