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