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 cb_info->req_id;
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_usr_activate_apps(pkgmgr_client *pc, const char **appids,
1024                 int n_apps, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1025 {
1026         GVariant *result;
1027         GVariantBuilder *builder;
1028         int ret = PKGMGR_R_ECOMM;
1029         char *req_key = NULL;
1030         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1031         struct cb_info *cb_info;
1032         int i;
1033
1034         if (pc == NULL || appids == NULL || n_apps < 1) {
1035                 ERR("invalid parameter");
1036                 return PKGMGR_R_EINVAL;
1037         }
1038
1039         if (client->pc_type != PC_REQUEST) {
1040                 ERR("client type is not PC_REQUEST");
1041                 return PKGMGR_R_EINVAL;
1042         }
1043
1044         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1045         for (i = 0; i < n_apps; i++)
1046                 g_variant_builder_add(builder, "s", appids[i]);
1047
1048         ret = pkgmgr_client_connection_send_request(client, "enable_apps",
1049                 g_variant_new("(uas)", uid, builder), &result);
1050         g_variant_builder_unref(builder);
1051         if (ret != PKGMGR_R_OK) {
1052                 ERR("request failed: %d", ret);
1053                 return ret;
1054         }
1055
1056         g_variant_get(result, "(i&s)", &ret, &req_key);
1057         if (req_key == NULL) {
1058                 g_variant_unref(result);
1059                 return PKGMGR_R_ECOMM;
1060         }
1061         if (ret != PKGMGR_R_OK) {
1062                 g_variant_unref(result);
1063                 return ret;
1064         }
1065
1066         cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
1067         if (cb_info == NULL) {
1068                 g_variant_unref(result);
1069                 return PKGMGR_R_ERROR;
1070         }
1071         g_variant_unref(result);
1072         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1073         if (ret != PKGMGR_R_OK) {
1074                 __free_cb_info(cb_info);
1075                 return ret;
1076         }
1077         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1078
1079         return cb_info->req_id;
1080 }
1081
1082 API int pkgmgr_client_activate_apps(pkgmgr_client *pc, const char **appids,
1083                 int n_apps, pkgmgr_app_handler app_event_cb, void *data)
1084 {
1085         return pkgmgr_client_usr_activate_apps(pc, appids, n_apps,
1086                         app_event_cb, data, _getuid());
1087 }
1088
1089 API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
1090                 const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1091 {
1092         GVariant *result;
1093         int ret = PKGMGR_R_ECOMM;
1094         char *req_key = NULL;
1095         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1096         struct cb_info *cb_info;
1097
1098         if (pc == NULL || appid == NULL) {
1099                 ERR("invalid parameter");
1100                 return PKGMGR_R_EINVAL;
1101         }
1102
1103         ret = pkgmgr_client_connection_send_request(client,
1104                         "enable_global_app_for_uid",
1105                         g_variant_new("(us)", uid, appid), &result);
1106         if (ret != PKGMGR_R_OK) {
1107                 ERR("request failed: %d", ret);
1108                 return ret;
1109         }
1110
1111         g_variant_get(result, "(i&s)", &ret, &req_key);
1112         if (req_key == NULL) {
1113                 g_variant_unref(result);
1114                 return PKGMGR_R_ECOMM;
1115         }
1116         if (ret != PKGMGR_R_OK) {
1117                 g_variant_unref(result);
1118                 return ret;
1119         }
1120
1121         cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1122                         req_key);
1123         if (cb_info == NULL) {
1124                 g_variant_unref(result);
1125                 return PKGMGR_R_ENOMEM;
1126         }
1127         g_variant_unref(result);
1128         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1129         if (ret != PKGMGR_R_OK) {
1130                 __free_cb_info(cb_info);
1131                 return ret;
1132         }
1133         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1134
1135         return cb_info->req_id;
1136 }
1137
1138 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1139                 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1140 {
1141         GVariant *result;
1142         int ret = PKGMGR_R_ECOMM;
1143         char *req_key = NULL;
1144         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1145         struct cb_info *cb_info;
1146
1147         if (pc == NULL || appid == NULL) {
1148                 ERR("invalid parameter");
1149                 return PKGMGR_R_EINVAL;
1150         }
1151
1152         ret = pkgmgr_client_connection_send_request(client, "disable_app",
1153                         g_variant_new("(us)", uid, appid), &result);
1154         if (ret != PKGMGR_R_OK) {
1155                 ERR("request failed: %d", ret);
1156                 return ret;
1157         }
1158
1159         g_variant_get(result, "(i&s)", &ret, &req_key);
1160         if (req_key == NULL) {
1161                 g_variant_unref(result);
1162                 return PKGMGR_R_ECOMM;
1163         }
1164         if (ret != PKGMGR_R_OK) {
1165                 g_variant_unref(result);
1166                 return ret;
1167         }
1168
1169         cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1170                         req_key);
1171         if (cb_info == NULL) {
1172                 g_variant_unref(result);
1173                 return PKGMGR_R_ENOMEM;
1174         }
1175         g_variant_unref(result);
1176         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1177         if (ret != PKGMGR_R_OK) {
1178                 __free_cb_info(cb_info);
1179                 return ret;
1180         }
1181         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1182
1183         return cb_info->req_id;
1184 }
1185
1186 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid,
1187                 pkgmgr_app_handler app_event_cb, void *data)
1188 {
1189         return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb, data,
1190                         _getuid());
1191 }
1192
1193 API int pkgmgr_client_usr_deactivate_apps(pkgmgr_client *pc,
1194                 const char **appids, int n_apps,
1195                 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1196 {
1197         GVariant *result;
1198         GVariantBuilder *builder;
1199         int ret = PKGMGR_R_ECOMM;
1200         char *req_key = NULL;
1201         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1202         struct cb_info *cb_info;
1203         int i;
1204
1205         if (pc == NULL || appids == NULL || n_apps < 1) {
1206                 ERR("invalid parameter");
1207                 return PKGMGR_R_EINVAL;
1208         }
1209
1210         if (client->pc_type != PC_REQUEST) {
1211                 ERR("client type is not PC_REQUEST");
1212                 return PKGMGR_R_EINVAL;
1213         }
1214
1215         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1216         for (i = 0; i < n_apps; i++)
1217                 g_variant_builder_add(builder, "s", appids[i]);
1218
1219         ret = pkgmgr_client_connection_send_request(client, "disable_apps",
1220                 g_variant_new("(uas)", uid, builder), &result);
1221         g_variant_builder_unref(builder);
1222         if (ret != PKGMGR_R_OK) {
1223                 ERR("request failed: %d", ret);
1224                 return ret;
1225         }
1226
1227         g_variant_get(result, "(i&s)", &ret, &req_key);
1228         if (req_key == NULL) {
1229                 g_variant_unref(result);
1230                 return PKGMGR_R_ECOMM;
1231         }
1232         if (ret != PKGMGR_R_OK) {
1233                 g_variant_unref(result);
1234                 return ret;
1235         }
1236
1237         cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
1238         if (cb_info == NULL) {
1239                 g_variant_unref(result);
1240                 return PKGMGR_R_ERROR;
1241         }
1242         g_variant_unref(result);
1243         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1244         if (ret != PKGMGR_R_OK) {
1245                 __free_cb_info(cb_info);
1246                 return ret;
1247         }
1248         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1249
1250         return cb_info->req_id;
1251 }
1252
1253 API int pkgmgr_client_deactivate_apps(pkgmgr_client *pc, const char **appids,
1254                 int n_apps, pkgmgr_app_handler app_event_cb, void *data)
1255 {
1256         return pkgmgr_client_usr_deactivate_apps(pc, appids, n_apps,
1257                         app_event_cb, data, _getuid());
1258 }
1259
1260 API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
1261                 const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1262 {
1263         GVariant *result;
1264         int ret = PKGMGR_R_ECOMM;
1265         char *req_key = NULL;
1266         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1267         struct cb_info *cb_info;
1268
1269         if (pc == NULL || appid == NULL) {
1270                 ERR("invalid parameter");
1271                 return PKGMGR_R_EINVAL;
1272         }
1273
1274         ret = pkgmgr_client_connection_send_request(client,
1275                         "disable_global_app_for_uid",
1276                         g_variant_new("(us)", uid, appid), &result);
1277         if (ret != PKGMGR_R_OK) {
1278                 ERR("request failed: %d", ret);
1279                 return ret;
1280         }
1281
1282         g_variant_get(result, "(i&s)", &ret, &req_key);
1283         if (req_key == NULL) {
1284                 g_variant_unref(result);
1285                 return PKGMGR_R_ECOMM;
1286         }
1287         if (ret != PKGMGR_R_OK) {
1288                 g_variant_unref(result);
1289                 return ret;
1290         }
1291
1292         cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1293                         req_key);
1294         if (cb_info == NULL) {
1295                 g_variant_unref(result);
1296                 return PKGMGR_R_ENOMEM;
1297         }
1298         g_variant_unref(result);
1299         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1300         if (ret != PKGMGR_R_OK) {
1301                 __free_cb_info(cb_info);
1302                 return ret;
1303         }
1304         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1305
1306         return cb_info->req_id;
1307 }
1308
1309 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1310                 const char *pkg_type, const char *appid, pkgmgr_mode mode,
1311                 uid_t uid)
1312 {
1313         GVariant *result;
1314         int ret;
1315         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1316
1317         if (pc == NULL || appid == NULL || uid == GLOBAL_USER) {
1318                 ERR("invalid parameter");
1319                 return PKGMGR_R_EINVAL;
1320         }
1321
1322         if (client->pc_type != PC_REQUEST) {
1323                 ERR("client->pc_type is not PC_REQUEST");
1324                 return PKGMGR_R_EINVAL;
1325         }
1326
1327         ret = pkgmgr_client_connection_send_request(client, "cleardata",
1328                         g_variant_new("(us)", uid, appid), &result);
1329         if (ret != PKGMGR_R_OK) {
1330                 ERR("request failed: %d", ret);
1331                 return ret;
1332         }
1333
1334         g_variant_get(result, "(i)", &ret);
1335         g_variant_unref(result);
1336
1337         return ret;
1338 }
1339
1340 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1341                 const char *appid, pkgmgr_mode mode)
1342 {
1343         return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid, mode,
1344                         _getuid());
1345 }
1346
1347 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1348 {
1349         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1350
1351         if (pc == NULL) {
1352                 ERR("invalid parameter");
1353                 return PKGMGR_R_EINVAL;
1354         }
1355
1356         client->status_type = status_type;
1357
1358         return PKGMGR_R_OK;
1359 }
1360
1361 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1362                 void *data)
1363 {
1364         int ret;
1365         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1366         struct cb_info *cb_info;
1367
1368         if (pc == NULL || event_cb == NULL) {
1369                 ERR("invalid parameter");
1370                 return PKGMGR_R_EINVAL;
1371         }
1372
1373         if (client->pc_type != PC_LISTENING) {
1374                 ERR("client->pc_type is not PC_LISTENING");
1375                 return PKGMGR_R_EINVAL;
1376         }
1377
1378         cb_info = __create_event_cb_info(client, event_cb, data, NULL);
1379         if (cb_info == NULL)
1380                 return PKGMGR_R_ENOMEM;
1381         cb_info->status_type = client->status_type;
1382         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1383         if (ret != PKGMGR_R_OK) {
1384                 __free_cb_info(cb_info);
1385                 return ret;
1386         }
1387         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1388
1389         return cb_info->req_id;
1390 }
1391
1392 API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
1393                 pkgmgr_app_handler app_event_cb, void *data)
1394 {
1395         int ret;
1396         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1397         struct cb_info *cb_info;
1398
1399         if (pc == NULL || app_event_cb == NULL) {
1400                 ERR("invalid parameter");
1401                 return PKGMGR_R_EINVAL;
1402         }
1403
1404         if (client->pc_type != PC_LISTENING) {
1405                 ERR("client->pc_type is not PC_LISTENING");
1406                 return PKGMGR_R_EINVAL;
1407         }
1408
1409         cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL);
1410         if (cb_info == NULL)
1411                 return PKGMGR_R_ENOMEM;
1412         cb_info->status_type = client->status_type;
1413         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1414         if (ret != PKGMGR_R_OK) {
1415                 __free_cb_info(cb_info);
1416                 return ret;
1417         }
1418         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1419
1420         return cb_info->req_id;
1421 }
1422
1423 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
1424 {
1425         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1426         GList *tmp;
1427         GList *next;
1428         struct cb_info *cb_info;
1429
1430         if (pc == NULL) {
1431                 ERR("invalid parameter");
1432                 return PKGMGR_R_EINVAL;
1433         }
1434
1435         /* unset all callback */
1436         tmp = client->cb_info_list;
1437         while (tmp != NULL) {
1438                 next = tmp->next;
1439                 cb_info = (struct cb_info *)tmp->data;
1440                 pkgmgr_client_connection_unset_callback(pc, cb_info);
1441                 client->cb_info_list = g_list_delete_link(client->cb_info_list,
1442                                 tmp);
1443                 __free_cb_info(cb_info);
1444                 tmp = next;
1445         }
1446
1447         return PKGMGR_R_OK;
1448 }
1449
1450 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1451                 const char *pkgid, const char *key, const char *val)
1452 {
1453         /* client cannot broadcast signal */
1454         return PKGMGR_R_OK;
1455 }
1456
1457 /* TODO: deprecate(or remove) */
1458 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
1459                 int service_mode, pkgmgr_client *pc, const char *pkg_type,
1460                 const char *pkgid, const char *custom_info,
1461                 pkgmgr_handler event_cb, void *data)
1462 {
1463         return pkgmgr_client_usr_request_service(service_type, service_mode,
1464                         pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
1465                         data);
1466 }
1467
1468 API int pkgmgr_client_usr_request_service(
1469                 pkgmgr_request_service_type service_type, int service_mode,
1470                 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
1471                 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
1472                 void *data)
1473 {
1474         int ret = 0;
1475
1476         /* Check for NULL value of service type */
1477         retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1478         retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1479
1480         switch (service_type) {
1481         case PM_REQUEST_MOVE:
1482                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1483                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1484                 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1485
1486                 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1487                 break;
1488
1489         case PM_REQUEST_GET_SIZE:
1490                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1491                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1492                 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1493
1494                 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1495                 break;
1496
1497         case PM_REQUEST_KILL_APP:
1498         case PM_REQUEST_CHECK_APP:
1499                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1500                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1501
1502                 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1503                 if (ret < 0)
1504                         ERR("__check_app_process fail \n");
1505                 else
1506                         ret = PKGMGR_R_OK;
1507
1508                 break;
1509
1510         default:
1511                 ERR("Wrong Request\n");
1512                 ret = -1;
1513                 break;
1514         }
1515
1516 catch:
1517
1518         return ret;
1519 }
1520
1521
1522 API int pkgmgr_client_usr_request_size_info(uid_t uid)
1523 {
1524         int ret;
1525         struct pkgmgr_client *client;
1526
1527         client = pkgmgr_client_new(PC_REQUEST);
1528         if (client == NULL) {
1529                 ERR("out of memory");
1530                 return PKGMGR_R_ENOMEM;
1531         }
1532
1533         ret = __request_size_info(client, uid);
1534         if (ret < 0)
1535                 ERR("__request_size_info fail");
1536
1537         pkgmgr_client_free(client);
1538         return ret;
1539 }
1540
1541 API int pkgmgr_client_request_size_info(void)
1542 {
1543         /* get all package size (data, total) */
1544         return pkgmgr_client_usr_request_size_info(_getuid());
1545 }
1546
1547 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1548 {
1549         GVariant *result;
1550         int ret;
1551         struct pkgmgr_client_t *client;
1552
1553         if (pkgid == NULL || uid == GLOBAL_USER) {
1554                 ERR("invalid parameter");
1555                 return PKGMGR_R_EINVAL;
1556         }
1557
1558         client = pkgmgr_client_new(PC_REQUEST);
1559         if (client == NULL) {
1560                 ERR("out of memory");
1561                 return PKGMGR_R_ENOMEM;
1562         }
1563
1564         ret = pkgmgr_client_connection_send_request(client, "clearcache",
1565                         g_variant_new("(us)", uid, pkgid), &result);
1566         if (ret != PKGMGR_R_OK) {
1567                 ERR("request failed: %d", ret);
1568                 return ret;
1569         }
1570
1571         g_variant_get(result, "(i)", &ret);
1572         g_variant_unref(result);
1573
1574         return ret;
1575 }
1576
1577 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1578 {
1579         return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
1580 }
1581
1582 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1583 {
1584         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1585 }
1586
1587 API int pkgmgr_client_clear_all_cache_dir(void)
1588 {
1589         return pkgmgr_client_usr_clear_cache_dir(
1590                         PKG_CLEAR_ALL_CACHE, _getuid());
1591 }
1592
1593 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
1594                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1595                 void *data)
1596 {
1597         return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
1598                         _getuid());
1599 }
1600
1601 /* TODO: deprecate(or remove) */
1602 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
1603                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1604                 void *data, uid_t uid)
1605 {
1606         GVariant *result;
1607         int ret = PKGMGR_R_ECOMM;
1608         char *req_key = NULL;
1609         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1610         struct cb_info *cb_info;
1611
1612         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1613                 ERR("invalid parameter");
1614                 return PKGMGR_R_EINVAL;
1615         }
1616
1617         if (client->pc_type != PC_REQUEST) {
1618                 ERR("client->pc_type is not PC_REQUEST");
1619                 return PKGMGR_R_EINVAL;
1620         }
1621
1622         /* FIXME */
1623         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1624                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1625         else
1626                 get_type = PM_GET_PKG_SIZE_INFO;
1627
1628         ret = pkgmgr_client_connection_send_request(client, "getsize",
1629                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
1630         if (ret != PKGMGR_R_OK) {
1631                 ERR("request failed: %d", ret);
1632                 return ret;
1633         }
1634
1635         g_variant_get(result, "(i&s)", &ret, &req_key);
1636         if (req_key == NULL) {
1637                 g_variant_unref(result);
1638                 return PKGMGR_R_ECOMM;
1639         }
1640         if (ret != PKGMGR_R_OK) {
1641                 g_variant_unref(result);
1642                 return ret;
1643         }
1644
1645         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1646         if (cb_info == NULL) {
1647                 g_variant_unref(result);
1648                 return PKGMGR_R_ENOMEM;
1649         }
1650         g_variant_unref(result);
1651         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1652         if (ret != PKGMGR_R_OK) {
1653                 __free_cb_info(cb_info);
1654                 return ret;
1655         }
1656         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1657
1658         return PKGMGR_R_OK;
1659 }
1660
1661 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
1662                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1663                 void *user_data, uid_t uid)
1664 {
1665         GVariant *result;
1666         int ret = PKGMGR_R_ECOMM;
1667         char *req_key = NULL;
1668         int get_type;
1669         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1670         struct cb_info *cb_info;
1671
1672         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1673                 ERR("invalid parameter");
1674                 return PKGMGR_R_EINVAL;
1675         }
1676
1677         if (client->pc_type != PC_REQUEST) {
1678                 ERR("client->pc_type is not PC_REQUEST");
1679                 return PKGMGR_R_EINVAL;
1680         }
1681
1682         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1683                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1684         else
1685                 get_type = PM_GET_PKG_SIZE_INFO;
1686
1687         ret = pkgmgr_client_connection_send_request(client, "getsize",
1688                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
1689         if (ret != PKGMGR_R_OK) {
1690                 ERR("request failed: %d", ret);
1691                 return ret;
1692         }
1693
1694         g_variant_get(result, "(i&s)", &ret, &req_key);
1695         if (req_key == NULL) {
1696                 g_variant_unref(result);
1697                 return PKGMGR_R_ECOMM;
1698         }
1699         if (ret != PKGMGR_R_OK) {
1700                 g_variant_unref(result);
1701                 return ret;
1702         }
1703
1704         cb_info = __create_size_info_cb_info(client, event_cb, user_data,
1705                         req_key);
1706         if (cb_info == NULL) {
1707                 g_variant_unref(result);
1708                 return PKGMGR_R_ENOMEM;
1709         }
1710         g_variant_unref(result);
1711         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1712         if (ret != PKGMGR_R_OK) {
1713                 __free_cb_info(cb_info);
1714                 return ret;
1715         }
1716         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1717
1718         return PKGMGR_R_OK;
1719 }
1720
1721 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
1722                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1723                 void *user_data)
1724 {
1725         return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
1726                         user_data, _getuid());
1727 }
1728
1729 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
1730                 pkgmgr_total_pkg_size_info_receive_cb event_cb,
1731                 void *user_data, uid_t uid)
1732 {       /* total package size info */
1733         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1734                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
1735                         user_data, uid);
1736 }
1737
1738 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
1739                 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
1740 {
1741         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1742                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
1743                         user_data, _getuid());
1744 }
1745
1746 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
1747                 const char *resp_data, char **req_data, char **license_url)
1748 {
1749         GVariant *result;
1750         int ret;
1751         char *data;
1752         char *url;
1753         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1754
1755         if (pc == NULL || resp_data == NULL || req_data == NULL ||
1756                         license_url == NULL) {
1757                 ERR("invalid parameter");
1758                 return PKGMGR_R_EINVAL;
1759         }
1760
1761         if (client->pc_type != PC_REQUEST) {
1762                 ERR("client->pc_type is not PC_REQUEST");
1763                 return PKGMGR_R_EINVAL;
1764         }
1765
1766         ret = pkgmgr_client_connection_send_request(client,
1767                         "generate_license_request",
1768                         g_variant_new("(s)", resp_data), &result);
1769         if (ret != PKGMGR_R_OK) {
1770                 ERR("request failed: %d", ret);
1771                 return ret;
1772         }
1773
1774         g_variant_get(result, "(i&s&s)", &ret, &data, &url);
1775         if (ret != PKGMGR_R_OK) {
1776                 ERR("generate_license_request failed: %d", ret);
1777                 g_variant_unref(result);
1778                 return ret;
1779         }
1780
1781         *req_data = strdup(data);
1782         *license_url = strdup(url);
1783
1784         g_variant_unref(result);
1785
1786         return PKGMGR_R_OK;
1787 }
1788
1789 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
1790 {
1791         GVariant *result;
1792         int ret;
1793         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1794
1795         if (pc == NULL || resp_data == NULL) {
1796                 ERR("invalid parameter");
1797                 return PKGMGR_R_EINVAL;
1798         }
1799
1800         if (client->pc_type != PC_REQUEST) {
1801                 ERR("client->pc_type is not PC_REQUEST");
1802                 return PKGMGR_R_EINVAL;
1803         }
1804
1805         ret = pkgmgr_client_connection_send_request(client, "register_license",
1806                         g_variant_new("(s)", resp_data), &result);
1807         if (ret != PKGMGR_R_OK) {
1808                 ERR("request failed: %d", ret);
1809                 return ret;
1810         }
1811
1812         g_variant_get(result, "(i)", &ret);
1813         g_variant_unref(result);
1814         if (ret != PKGMGR_R_OK)
1815                 ERR("register license failed: %d", ret);
1816
1817         return ret;
1818 }
1819
1820 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
1821                 const char *drm_file_path, const char *decrypted_file_path)
1822 {
1823         GVariant *result;
1824         int ret;
1825         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1826
1827         if (pc == NULL || drm_file_path == NULL ||
1828                         decrypted_file_path == NULL) {
1829                 ERR("invalid parameter");
1830                 return PKGMGR_R_EINVAL;
1831         }
1832
1833         if (client->pc_type != PC_REQUEST) {
1834                 ERR("client->pc_type is not PC_REQUEST");
1835                 return PKGMGR_R_EINVAL;
1836         }
1837
1838         ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
1839                         g_variant_new("(ss)", drm_file_path,
1840                                 decrypted_file_path), &result);
1841         if (ret != PKGMGR_R_OK) {
1842                 ERR("request failed: %d", ret);
1843                 return ret;
1844         }
1845
1846         g_variant_get(result, "(i)", &ret);
1847         g_variant_unref(result);
1848         if (ret != PKGMGR_R_OK)
1849                 ERR("decrypt_package failed: %d", ret);
1850
1851         return ret;
1852 }
1853
1854 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
1855 {
1856         return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
1857 }
1858
1859 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
1860                 const char *appid, uid_t uid)
1861 {
1862         int ret;
1863         GVariant *result;
1864         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1865
1866         if (pc == NULL || appid == NULL) {
1867                 ERR("Invalid parameter");
1868                 return PKGMGR_R_EINVAL;
1869         }
1870
1871         ret = pkgmgr_client_connection_send_request(client,
1872                         "enable_app_splash_screen",
1873                         g_variant_new("(us)", uid, appid), &result);
1874         if (ret != PKGMGR_R_OK) {
1875                 ERR("request failed: %d", ret);
1876                 return ret;
1877         }
1878
1879         g_variant_get(result, "(i)", &ret);
1880         g_variant_unref(result);
1881         if (ret != PKGMGR_R_OK)
1882                 ERR("enable splash screen failed: %d", ret);
1883
1884         return ret;
1885 }
1886
1887 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
1888                 const char *appid)
1889 {
1890         return pkgmgr_client_usr_disable_splash_screen(pc, appid,
1891                         _getuid());
1892 }
1893
1894 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
1895                 const char *appid, uid_t uid)
1896 {
1897         int ret;
1898         GVariant *result;
1899         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1900
1901         if (pc == NULL || appid == NULL) {
1902                 ERR("Invalid parameter");
1903                 return PKGMGR_R_EINVAL;
1904         }
1905
1906         ret = pkgmgr_client_connection_send_request(client,
1907                         "disable_app_splash_screen",
1908                         g_variant_new("(us)", uid, appid), &result);
1909         if (ret != PKGMGR_R_OK) {
1910                 ERR("request failed: %d", ret);
1911                 return ret;
1912         }
1913
1914         g_variant_get(result, "(i)", &ret);
1915         g_variant_unref(result);
1916         if (ret != PKGMGR_R_OK)
1917                 ERR("disable splash screen failed: %d", ret);
1918
1919         return ret;
1920 }
1921
1922 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1923                 int mode, uid_t uid)
1924 {
1925         GVariant *result;
1926         int ret = PKGMGR_R_ECOMM;
1927         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1928
1929         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1930                 ERR("invalid parameter");
1931                 return PKGMGR_R_EINVAL;
1932         }
1933
1934         ret = pkgmgr_client_connection_send_request(client,
1935                         "set_restriction_mode",
1936                         g_variant_new("(usi)", uid, pkgid, mode), &result);
1937         if (ret != PKGMGR_R_OK) {
1938                 ERR("request failed: %d", ret);
1939                 return ret;
1940         }
1941
1942         g_variant_get(result, "(i)", &ret);
1943         g_variant_unref(result);
1944
1945         return ret;
1946 }
1947
1948 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
1949                 const char *pkgid, int mode, uid_t uid)
1950 {
1951         return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
1952 }
1953
1954 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
1955                 const char *pkgid, int mode)
1956 {
1957         return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
1958                         _getuid());
1959 }
1960
1961 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1962                 int mode, uid_t uid)
1963 {
1964         GVariant *result;
1965         int ret = PKGMGR_R_ECOMM;
1966         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1967
1968         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1969                 ERR("invalid parameter");
1970                 return PKGMGR_R_EINVAL;
1971         }
1972
1973         ret = pkgmgr_client_connection_send_request(client,
1974                         "unset_restriction_mode",
1975                         g_variant_new("(usi)", uid, pkgid, mode), &result);
1976         if (ret != PKGMGR_R_OK) {
1977                 ERR("request failed: %d", ret);
1978                 return ret;
1979         }
1980
1981         g_variant_get(result, "(i)", &ret);
1982         g_variant_unref(result);
1983
1984         return ret;
1985
1986 }
1987
1988 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
1989                 const char *pkgid, int mode, uid_t uid)
1990 {
1991         return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
1992 }
1993
1994 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
1995                 const char *pkgid, int mode)
1996 {
1997         return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
1998                         _getuid());
1999 }
2000
2001 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2002                 int *mode, uid_t uid)
2003 {
2004         GVariant *result;
2005         int ret = PKGMGR_R_ECOMM;
2006         gint m;
2007         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2008
2009         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
2010                 ERR("invalid parameter");
2011                 return PKGMGR_R_EINVAL;
2012         }
2013
2014         ret = pkgmgr_client_connection_send_request(client,
2015                         "get_restriction_mode",
2016                         g_variant_new("(us)", uid, pkgid), &result);
2017         if (ret != PKGMGR_R_OK) {
2018                 ERR("request failed: %d", ret);
2019                 return ret;
2020         }
2021
2022         g_variant_get(result, "(ii)", &m, &ret);
2023         g_variant_unref(result);
2024         if (ret != PKGMGR_R_OK)
2025                 return ret;
2026
2027         *mode = m;
2028
2029         return PKGMGR_R_OK;
2030 }
2031
2032 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
2033                 const char *pkgid, int *mode, uid_t uid)
2034 {
2035         return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
2036 }
2037
2038 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
2039                 const char *pkgid, int *mode)
2040 {
2041         return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
2042                         _getuid());
2043 }
2044
2045 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
2046                 uid_t uid)
2047 {
2048         GVariant *result;
2049         int ret = PKGMGR_R_ECOMM;
2050         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2051
2052         if (pc == NULL) {
2053                 ERR("invalid parameter");
2054                 return PKGMGR_R_EINVAL;
2055         }
2056
2057         ret = pkgmgr_client_connection_send_request(client,
2058                         "set_restriction_mode",
2059                         g_variant_new("(usi)", uid, "", mode), &result);
2060         if (ret != PKGMGR_R_OK) {
2061                 ERR("request failed: %d", ret);
2062                 return ret;
2063         }
2064
2065         g_variant_get(result, "(i)", &ret);
2066         g_variant_unref(result);
2067
2068         return ret;
2069 }
2070
2071 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
2072 {
2073         return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
2074 }
2075
2076 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
2077                 uid_t uid)
2078 {
2079         GVariant *result;
2080         int ret = PKGMGR_R_ECOMM;
2081         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2082
2083         if (pc == NULL) {
2084                 ERR("invalid parameter");
2085                 return PKGMGR_R_EINVAL;
2086         }
2087
2088         ret = pkgmgr_client_connection_send_request(client,
2089                         "unset_restriction_mode",
2090                         g_variant_new("(usi)", uid, "", mode), &result);
2091         if (ret != PKGMGR_R_OK) {
2092                 ERR("request failed: %d", ret);
2093                 return ret;
2094         }
2095
2096         g_variant_get(result, "(i)", &ret);
2097         g_variant_unref(result);
2098
2099         return ret;
2100 }
2101
2102 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
2103 {
2104         return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
2105 }
2106
2107 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
2108                 int *mode, uid_t uid)
2109 {
2110         GVariant *result;
2111         int ret = PKGMGR_R_ECOMM;
2112         gint m;
2113         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2114
2115         if (pc == NULL) {
2116                 ERR("invalid parameter");
2117                 return PKGMGR_R_EINVAL;
2118         }
2119
2120         ret = pkgmgr_client_connection_send_request(client,
2121                         "get_restriction_mode",
2122                         g_variant_new("(us)", uid, ""), &result);
2123         if (ret != PKGMGR_R_OK) {
2124                 ERR("request failed: %d", ret);
2125                 return ret;
2126         }
2127
2128         g_variant_get(result, "(ii)", &m, &ret);
2129         g_variant_unref(result);
2130         if (ret != PKGMGR_R_OK)
2131                 return ret;
2132
2133         *mode = m;
2134
2135         return PKGMGR_R_OK;
2136 }
2137
2138 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
2139 {
2140         return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
2141 }
2142
2143 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
2144 {
2145         int ret;
2146         pkg_plugin_set *plugin_set;
2147         package_manager_pkg_detail_info_t *info;
2148         char *pkg_type;
2149
2150         if (pkg_path == NULL) {
2151                 ERR("invalid parameter");
2152                 return NULL;
2153         }
2154
2155         pkg_type = __get_type_from_path(pkg_path);
2156         if (pkg_type == NULL) {
2157                 ERR("cannot get pkg type");
2158                 return NULL;
2159         }
2160
2161         plugin_set = _package_manager_load_library(pkg_type);
2162         if (plugin_set == NULL) {
2163                 ERR("failed to load library for %s", pkg_type);
2164                 free(pkg_type);
2165                 return NULL;
2166         }
2167
2168         info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2169         if (info == NULL) {
2170                 ERR("out of memory");
2171                 free(pkg_type);
2172                 return NULL;
2173         }
2174
2175         ret = plugin_set->get_pkg_detail_info_from_package(pkg_path, info);
2176         if (ret) {
2177                 ERR("get_pkg_detail_info_from_package failed");
2178                 free(info);
2179                 free(pkg_type);
2180                 return NULL;
2181         }
2182
2183         free(pkg_type);
2184
2185         return (pkgmgr_info *)info;
2186 }
2187
2188 API int pkgmgr_client_free_pkginfo(pkgmgr_info *info)
2189 {
2190         package_manager_pkg_detail_info_t *pkg_info =
2191                 (package_manager_pkg_detail_info_t *)info;
2192
2193         if (info == NULL) {
2194                 ERR("invalid parameter");
2195                 return PKGMGR_R_EINVAL;
2196         }
2197
2198         free(pkg_info->icon_buf);
2199         free(pkg_info);
2200
2201         return PKGMGR_R_OK;
2202 }
2203
2204 API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid,
2205                 char *label, uid_t uid)
2206 {
2207         GVariant *result;
2208         int ret = -1;
2209         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2210
2211         if (pc == NULL || appid == NULL || label == NULL) {
2212                 ERR("Invalid parameter");
2213                 return PKGMGR_R_EINVAL;
2214         }
2215
2216         ret = pkgmgr_client_connection_send_request(client,
2217                         "set_app_label",
2218                         g_variant_new("(uss)", uid, appid, label), &result);
2219         if (ret != PKGMGR_R_OK) {
2220                 ERR("Request failed: %d", ret);
2221                 return ret;
2222         }
2223
2224         g_variant_get(result, "(i)", &ret);
2225         g_variant_unref(result);
2226
2227         return ret;
2228 }
2229
2230 API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label)
2231 {
2232         return pkgmgr_client_usr_set_app_label(pc, appid, label, _getuid());
2233 }
2234
2235 API int pkgmgr_client_set_debug_mode(pkgmgr_client *pc, bool debug_mode)
2236 {
2237         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2238
2239         if (pc == NULL) {
2240                 ERR("invalid parameter");
2241                 return PKGMGR_R_EINVAL;
2242         }
2243
2244         client->debug_mode = debug_mode;
2245
2246         return PKGMGR_R_OK;
2247 }
2248
2249 API int pkgmgr_client_usr_migrate_external_image(pkgmgr_client *pc,
2250                 const char *pkgid, uid_t uid)
2251 {
2252         GVariant *result;
2253         int ret = PKGMGR_R_ECOMM;
2254         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2255
2256         if (pc == NULL) {
2257                 ERR("invalid parameter");
2258                 return PKGMGR_R_EINVAL;
2259         }
2260
2261         ret = pkgmgr_client_connection_send_request(client,
2262                         "migrate_external_image",
2263                         g_variant_new("(us)", uid, pkgid), &result);
2264         if (ret != PKGMGR_R_OK) {
2265                 ERR("request failed: %d", ret);
2266                 return ret;
2267         }
2268
2269         g_variant_get(result, "(i)", &ret);
2270         g_variant_unref(result);
2271
2272         return ret;
2273 }