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