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