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