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