client/src/pkgmgr.c

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