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