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