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