client/src/pkgmgr.c

   1 /*
   2  * slp-pkgmgr
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
   7  * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <dlfcn.h>
  28 #include <dirent.h>
  29 #include <fcntl.h>
  30 #include <sys/wait.h>
  31 #include <sys/time.h>
  32 #include <unzip.h>
  33
  34 #include <glib.h>
  35
  36 #include <pkgmgr-info.h>
  37 #include <iniparser.h>
  38 /* For multi-user support */
  39 #include <tzplatform_config.h>
  40
  41 #include "package-manager.h"
  42 #include "pkgmgr_client_debug.h"
  43 #include "pkgmgr_client_internal.h"
  44
  45 /* API export macro */
  46 #ifndef API
  47 #define API __attribute__ ((visibility("default")))
  48 #endif
  49
  50 #define BINSH_NAME      "/bin/sh"
  51 #define BINSH_SIZE      7
  52
  53 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
  54 #define REGULAR_USER 5000
  55
  56 static inline uid_t _getuid(void)
  57 {
  58         uid_t uid = getuid();
  59
  60         if (uid < REGULAR_USER)
  61                 return GLOBAL_USER;
  62         else
  63                 return uid;
  64 }
  65
  66 static int _get_request_id()
  67 {
  68         static int internal_req_id = 1;
  69
  70         return internal_req_id++;
  71 }
  72
  73 static struct cb_info *__create_event_cb_info(struct pkgmgr_client_t *client,
  74                 pkgmgr_handler event_cb, void *data, const char *req_key)
  75 {
  76         struct cb_info *cb_info;
  77
  78         cb_info = calloc(1, sizeof(struct cb_info));
  79         if (cb_info == NULL) {
  80                 ERR("out of memory");
  81                 return NULL;
  82         }
  83         cb_info->client = client;
  84         cb_info->event_cb = event_cb;
  85         cb_info->data = data;
  86         cb_info->req_id = _get_request_id();
  87         if (req_key != NULL) {
  88                 cb_info->req_key = strdup(req_key);
  89                 if (cb_info->req_key == NULL) {
  90                         ERR("out of memory");
  91                         free(cb_info);
  92                         return NULL;
  93                 }
  94         }
  95
  96         return cb_info;
  97 }
  98
  99 static struct cb_info *__create_app_event_cb_info(
 100                 struct pkgmgr_client_t *client, pkgmgr_app_handler app_event_cb,
 101                 void *data, const char *req_key)
 102 {
 103         struct cb_info *cb_info;
 104
 105         cb_info = calloc(1, sizeof(struct cb_info));
 106         if (cb_info == NULL) {
 107                 ERR("out of memory");
 108                 return NULL;
 109         }
 110         cb_info->client = client;
 111         cb_info->app_event_cb = app_event_cb;
 112         cb_info->data = data;
 113         cb_info->req_id = _get_request_id();
 114         if (req_key != NULL) {
 115                 cb_info->req_key = strdup(req_key);
 116                 if (cb_info->req_key == NULL) {
 117                         ERR("out of memory");
 118                         free(cb_info);
 119                         return NULL;
 120                 }
 121         }
 122
 123         return cb_info;
 124 }
 125
 126 static struct cb_info *__create_size_info_cb_info(
 127                 struct pkgmgr_client_t *client,
 128                 pkgmgr_pkg_size_info_receive_cb size_info_cb,
 129                 void *data, const char *req_key)
 130 {
 131         struct cb_info *cb_info;
 132
 133         cb_info = calloc(1, sizeof(struct cb_info));
 134         if (cb_info == NULL) {
 135                 ERR("out of memory");
 136                 return NULL;
 137         }
 138         cb_info->client = client;
 139         cb_info->size_info_cb = size_info_cb;
 140         cb_info->data = data;
 141         cb_info->req_id = _get_request_id();
 142         if (req_key != NULL) {
 143                 cb_info->req_key = strdup(req_key);
 144                 if (cb_info->req_key == NULL) {
 145                         ERR("out of memory");
 146                         free(cb_info);
 147                         return NULL;
 148                 }
 149         }
 150
 151         return cb_info;
 152 }
 153
 154 static gboolean __free_cb_info_at_main_thread(gpointer user_data)
 155 {
 156         struct cb_info *cb_info = (struct cb_info *)user_data;
 157         g_list_free(cb_info->sid_list);
 158         free(cb_info->req_key);
 159         free(cb_info);
 160
 161         return G_SOURCE_REMOVE;
 162 }
 163
 164 static void __free_cb_info(struct cb_info *cb_info)
 165 {
 166         g_idle_add(__free_cb_info_at_main_thread, cb_info);
 167 }
 168
 169 static int __get_size_process(pkgmgr_client *pc, const char *pkgid, uid_t uid,
 170                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
 171                 void *data)
 172 {
 173         GVariant *result;
 174         int ret = PKGMGR_R_ECOMM;
 175         long long size_info = 0;
 176         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 177
 178         if (pc == NULL || pkgid == NULL) {
 179                 ERR("invalid parameter");
 180                 return PKGMGR_R_EINVAL;
 181         }
 182
 183         if (client->pc_type != PC_REQUEST) {
 184                 ERR("client->pc_type is not PC_REQUEST");
 185                 return PKGMGR_R_EINVAL;
 186         }
 187
 188         ret = pkgmgr_client_connection_send_request(client, "getsize_sync",
 189                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
 190         if (ret != PKGMGR_R_OK) {
 191                 ERR("request failed: %d", ret);
 192                 return ret;
 193         }
 194
 195         g_variant_get(result, "(ix)", &ret, &size_info);
 196         if (ret != PKGMGR_R_OK) {
 197                 ERR("request result failed: %d", ret);
 198                 g_variant_unref(result);
 199                 return ret;
 200         }
 201
 202         if (size_info < 0) {
 203                 ERR("invalid size_info=(%lld)", size_info);
 204                 ret = -1;
 205         } else {
 206                 ret = (int)size_info;
 207                 DBG("size_info(%lld), return size(%d)", size_info, ret);
 208         }
 209
 210         g_variant_unref(result);
 211
 212         return ret;
 213 }
 214
 215 static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid,
 216                 const char *pkg_type, uid_t uid, pkgmgr_move_type move_type,
 217                 pkgmgr_handler event_cb, void *data)
 218 {
 219         int ret;
 220
 221         ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, event_cb, data, uid);
 222         if (ret < 0) {
 223                 ERR("move request failed");
 224                 return ret;
 225         }
 226
 227         return ret;
 228 }
 229
 230 static int __check_app_process(pkgmgr_request_service_type service_type,
 231                 pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data)
 232 {
 233         GVariant *result;
 234         int ret = PKGMGR_R_ECOMM;
 235         pkgmgrinfo_pkginfo_h handle;
 236         int pid = -1;
 237         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 238
 239         retvm_if(client->pc_type != PC_REQUEST, PKGMGR_R_EINVAL, "client->pc_type is not PC_REQUEST\n");
 240
 241         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
 242         if (ret != PMINFO_R_OK) {
 243                 ERR("pkgmgrinfo_pkginfo_get_pkginfo failed");
 244                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 245                 return PKGMGR_R_ERROR;
 246         }
 247
 248         if (service_type == PM_REQUEST_KILL_APP) {
 249                 ret = pkgmgr_client_connection_send_request(client, "kill",
 250                                 g_variant_new("(us)", uid, pkgid), &result);
 251         } else if (service_type == PM_REQUEST_CHECK_APP) {
 252                 ret = pkgmgr_client_connection_send_request(client, "check",
 253                                 g_variant_new("(us)", uid, pkgid), &result);
 254         } else {
 255                 ERR("unexpected service type: %d", service_type);
 256                 ret = PKGMGR_R_ERROR;
 257         }
 258
 259         if (ret != PKGMGR_R_OK) {
 260                 ERR("request failed: %d", ret);
 261                 return ret;
 262         }
 263
 264         g_variant_get(result, "(ii)", &ret, &pid);
 265         g_variant_unref(result);
 266         if (ret != PKGMGR_R_OK) {
 267                 ERR("request failed, ret=%d", ret);
 268                 return ret;
 269         }
 270
 271         *(int *)data = pid;
 272
 273         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 274
 275         return ret;
 276
 277 }
 278
 279 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 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1667 {
1668         GVariant *result;
1669         int ret;
1670         struct pkgmgr_client_t *client;
1671
1672         if (pkgid == NULL || uid == GLOBAL_USER) {
1673                 ERR("invalid parameter");
1674                 return PKGMGR_R_EINVAL;
1675         }
1676
1677         client = pkgmgr_client_new(PC_REQUEST);
1678         if (client == NULL) {
1679                 ERR("out of memory");
1680                 return PKGMGR_R_ENOMEM;
1681         }
1682
1683         ret = pkgmgr_client_connection_send_request(client, "clearcache",
1684                         g_variant_new("(us)", uid, pkgid), &result);
1685         if (ret != PKGMGR_R_OK) {
1686                 ERR("request failed: %d", ret);
1687                 pkgmgr_client_free(client);
1688                 return ret;
1689         }
1690
1691         g_variant_get(result, "(i)", &ret);
1692         g_variant_unref(result);
1693         pkgmgr_client_free(client);
1694
1695         return ret;
1696 }
1697
1698 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1699 {
1700         return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
1701 }
1702
1703 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1704 {
1705         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1706 }
1707
1708 API int pkgmgr_client_clear_all_cache_dir(void)
1709 {
1710         return pkgmgr_client_usr_clear_cache_dir(
1711                         PKG_CLEAR_ALL_CACHE, _getuid());
1712 }
1713
1714 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
1715                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1716                 void *data)
1717 {
1718         return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
1719                         _getuid());
1720 }
1721
1722 /* TODO: deprecate(or remove) */
1723 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
1724                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1725                 void *data, uid_t uid)
1726 {
1727         GVariant *result;
1728         int ret = PKGMGR_R_ECOMM;
1729         char *req_key = NULL;
1730         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1731         struct cb_info *cb_info;
1732
1733         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1734                 ERR("invalid parameter");
1735                 return PKGMGR_R_EINVAL;
1736         }
1737
1738         if (client->pc_type != PC_REQUEST) {
1739                 ERR("client->pc_type is not PC_REQUEST");
1740                 return PKGMGR_R_EINVAL;
1741         }
1742
1743         /* FIXME */
1744         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1745                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1746         else
1747                 get_type = PM_GET_PKG_SIZE_INFO;
1748
1749         ret = pkgmgr_client_connection_send_request(client, "getsize",
1750                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
1751         if (ret != PKGMGR_R_OK) {
1752                 ERR("request failed: %d", ret);
1753                 return ret;
1754         }
1755
1756         g_variant_get(result, "(i&s)", &ret, &req_key);
1757         if (req_key == NULL) {
1758                 g_variant_unref(result);
1759                 return PKGMGR_R_ECOMM;
1760         }
1761         if (ret != PKGMGR_R_OK) {
1762                 g_variant_unref(result);
1763                 return ret;
1764         }
1765
1766         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1767         if (cb_info == NULL) {
1768                 g_variant_unref(result);
1769                 return PKGMGR_R_ENOMEM;
1770         }
1771         g_variant_unref(result);
1772         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1773         if (ret != PKGMGR_R_OK) {
1774                 __free_cb_info(cb_info);
1775                 return ret;
1776         }
1777         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1778
1779         return PKGMGR_R_OK;
1780 }
1781
1782 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
1783                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1784                 void *user_data, uid_t uid)
1785 {
1786         GVariant *result;
1787         int ret = PKGMGR_R_ECOMM;
1788         char *req_key = NULL;
1789         int get_type;
1790         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1791         struct cb_info *cb_info;
1792
1793         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1794                 ERR("invalid parameter");
1795                 return PKGMGR_R_EINVAL;
1796         }
1797
1798         if (client->pc_type != PC_REQUEST) {
1799                 ERR("client->pc_type is not PC_REQUEST");
1800                 return PKGMGR_R_EINVAL;
1801         }
1802
1803         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1804                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1805         else
1806                 get_type = PM_GET_PKG_SIZE_INFO;
1807
1808         ret = pkgmgr_client_connection_send_request(client, "getsize",
1809                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
1810         if (ret != PKGMGR_R_OK) {
1811                 ERR("request failed: %d", ret);
1812                 return ret;
1813         }
1814
1815         g_variant_get(result, "(i&s)", &ret, &req_key);
1816         if (req_key == NULL) {
1817                 g_variant_unref(result);
1818                 return PKGMGR_R_ECOMM;
1819         }
1820         if (ret != PKGMGR_R_OK) {
1821                 g_variant_unref(result);
1822                 return ret;
1823         }
1824
1825         cb_info = __create_size_info_cb_info(client, event_cb, user_data,
1826                         req_key);
1827         if (cb_info == NULL) {
1828                 g_variant_unref(result);
1829                 return PKGMGR_R_ENOMEM;
1830         }
1831         g_variant_unref(result);
1832         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1833         if (ret != PKGMGR_R_OK) {
1834                 __free_cb_info(cb_info);
1835                 return ret;
1836         }
1837         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1838
1839         return PKGMGR_R_OK;
1840 }
1841
1842 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
1843                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1844                 void *user_data)
1845 {
1846         return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
1847                         user_data, _getuid());
1848 }
1849
1850 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
1851                 pkgmgr_total_pkg_size_info_receive_cb event_cb,
1852                 void *user_data, uid_t uid)
1853 {       /* total package size info */
1854         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1855                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
1856                         user_data, uid);
1857 }
1858
1859 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
1860                 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
1861 {
1862         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1863                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
1864                         user_data, _getuid());
1865 }
1866
1867 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
1868                 const char *resp_data, char **req_data, char **license_url)
1869 {
1870         GVariant *result;
1871         int ret;
1872         char *data;
1873         char *url;
1874         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1875
1876         if (pc == NULL || resp_data == NULL || req_data == NULL ||
1877                         license_url == NULL) {
1878                 ERR("invalid parameter");
1879                 return PKGMGR_R_EINVAL;
1880         }
1881
1882         if (client->pc_type != PC_REQUEST) {
1883                 ERR("client->pc_type is not PC_REQUEST");
1884                 return PKGMGR_R_EINVAL;
1885         }
1886
1887         ret = pkgmgr_client_connection_send_request(client,
1888                         "generate_license_request",
1889                         g_variant_new("(s)", resp_data), &result);
1890         if (ret != PKGMGR_R_OK) {
1891                 ERR("request failed: %d", ret);
1892                 return ret;
1893         }
1894
1895         g_variant_get(result, "(i&s&s)", &ret, &data, &url);
1896         if (ret != PKGMGR_R_OK) {
1897                 ERR("generate_license_request failed: %d", ret);
1898                 g_variant_unref(result);
1899                 return ret;
1900         }
1901
1902         *req_data = strdup(data);
1903         *license_url = strdup(url);
1904
1905         g_variant_unref(result);
1906
1907         return PKGMGR_R_OK;
1908 }
1909
1910 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
1911 {
1912         GVariant *result;
1913         int ret;
1914         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1915
1916         if (pc == NULL || resp_data == NULL) {
1917                 ERR("invalid parameter");
1918                 return PKGMGR_R_EINVAL;
1919         }
1920
1921         if (client->pc_type != PC_REQUEST) {
1922                 ERR("client->pc_type is not PC_REQUEST");
1923                 return PKGMGR_R_EINVAL;
1924         }
1925
1926         ret = pkgmgr_client_connection_send_request(client, "register_license",
1927                         g_variant_new("(s)", resp_data), &result);
1928         if (ret != PKGMGR_R_OK) {
1929                 ERR("request failed: %d", ret);
1930                 return ret;
1931         }
1932
1933         g_variant_get(result, "(i)", &ret);
1934         g_variant_unref(result);
1935         if (ret != PKGMGR_R_OK)
1936                 ERR("register license failed: %d", ret);
1937
1938         return ret;
1939 }
1940
1941 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
1942                 const char *drm_file_path, const char *decrypted_file_path)
1943 {
1944         GVariant *result;
1945         int ret;
1946         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1947
1948         if (pc == NULL || drm_file_path == NULL ||
1949                         decrypted_file_path == NULL) {
1950                 ERR("invalid parameter");
1951                 return PKGMGR_R_EINVAL;
1952         }
1953
1954         if (client->pc_type != PC_REQUEST) {
1955                 ERR("client->pc_type is not PC_REQUEST");
1956                 return PKGMGR_R_EINVAL;
1957         }
1958
1959         ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
1960                         g_variant_new("(ss)", drm_file_path,
1961                                 decrypted_file_path), &result);
1962         if (ret != PKGMGR_R_OK) {
1963                 ERR("request failed: %d", ret);
1964                 return ret;
1965         }
1966
1967         g_variant_get(result, "(i)", &ret);
1968         g_variant_unref(result);
1969         if (ret != PKGMGR_R_OK)
1970                 ERR("decrypt_package failed: %d", ret);
1971
1972         return ret;
1973 }
1974
1975 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
1976 {
1977         return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
1978 }
1979
1980 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
1981                 const char *appid, uid_t uid)
1982 {
1983         int ret;
1984         GVariant *result;
1985         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1986
1987         if (pc == NULL || appid == NULL) {
1988                 ERR("Invalid parameter");
1989                 return PKGMGR_R_EINVAL;
1990         }
1991
1992         ret = pkgmgr_client_connection_send_request(client,
1993                         "enable_app_splash_screen",
1994                         g_variant_new("(us)", uid, appid), &result);
1995         if (ret != PKGMGR_R_OK) {
1996                 ERR("request failed: %d", ret);
1997                 return ret;
1998         }
1999
2000         g_variant_get(result, "(i)", &ret);
2001         g_variant_unref(result);
2002         if (ret != PKGMGR_R_OK)
2003                 ERR("enable splash screen failed: %d", ret);
2004
2005         return ret;
2006 }
2007
2008 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
2009                 const char *appid)
2010 {
2011         return pkgmgr_client_usr_disable_splash_screen(pc, appid,
2012                         _getuid());
2013 }
2014
2015 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
2016                 const char *appid, uid_t uid)
2017 {
2018         int ret;
2019         GVariant *result;
2020         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2021
2022         if (pc == NULL || appid == NULL) {
2023                 ERR("Invalid parameter");
2024                 return PKGMGR_R_EINVAL;
2025         }
2026
2027         ret = pkgmgr_client_connection_send_request(client,
2028                         "disable_app_splash_screen",
2029                         g_variant_new("(us)", uid, appid), &result);
2030         if (ret != PKGMGR_R_OK) {
2031                 ERR("request failed: %d", ret);
2032                 return ret;
2033         }
2034
2035         g_variant_get(result, "(i)", &ret);
2036         g_variant_unref(result);
2037         if (ret != PKGMGR_R_OK)
2038                 ERR("disable splash screen failed: %d", ret);
2039
2040         return ret;
2041 }
2042
2043 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2044                 int mode, uid_t uid)
2045 {
2046         GVariant *result;
2047         int ret = PKGMGR_R_ECOMM;
2048         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2049
2050         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2051                 ERR("invalid parameter");
2052                 return PKGMGR_R_EINVAL;
2053         }
2054
2055         ret = pkgmgr_client_connection_send_request(client,
2056                         "set_restriction_mode",
2057                         g_variant_new("(usi)", uid, pkgid, mode), &result);
2058         if (ret != PKGMGR_R_OK) {
2059                 ERR("request failed: %d", ret);
2060                 return ret;
2061         }
2062
2063         g_variant_get(result, "(i)", &ret);
2064         g_variant_unref(result);
2065
2066         return ret;
2067 }
2068
2069 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
2070                 const char *pkgid, int mode, uid_t uid)
2071 {
2072         return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
2073 }
2074
2075 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
2076                 const char *pkgid, int mode)
2077 {
2078         return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
2079                         _getuid());
2080 }
2081
2082 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2083                 int mode, uid_t uid)
2084 {
2085         GVariant *result;
2086         int ret = PKGMGR_R_ECOMM;
2087         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2088
2089         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2090                 ERR("invalid parameter");
2091                 return PKGMGR_R_EINVAL;
2092         }
2093
2094         ret = pkgmgr_client_connection_send_request(client,
2095                         "unset_restriction_mode",
2096                         g_variant_new("(usi)", uid, pkgid, mode), &result);
2097         if (ret != PKGMGR_R_OK) {
2098                 ERR("request failed: %d", ret);
2099                 return ret;
2100         }
2101
2102         g_variant_get(result, "(i)", &ret);
2103         g_variant_unref(result);
2104
2105         return ret;
2106
2107 }
2108
2109 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
2110                 const char *pkgid, int mode, uid_t uid)
2111 {
2112         return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
2113 }
2114
2115 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
2116                 const char *pkgid, int mode)
2117 {
2118         return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
2119                         _getuid());
2120 }
2121
2122 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2123                 int *mode, uid_t uid)
2124 {
2125         GVariant *result;
2126         int ret = PKGMGR_R_ECOMM;
2127         gint m;
2128         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2129
2130         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
2131                 ERR("invalid parameter");
2132                 return PKGMGR_R_EINVAL;
2133         }
2134
2135         ret = pkgmgr_client_connection_send_request(client,
2136                         "get_restriction_mode",
2137                         g_variant_new("(us)", uid, pkgid), &result);
2138         if (ret != PKGMGR_R_OK) {
2139                 ERR("request failed: %d", ret);
2140                 return ret;
2141         }
2142
2143         g_variant_get(result, "(ii)", &m, &ret);
2144         g_variant_unref(result);
2145         if (ret != PKGMGR_R_OK)
2146                 return ret;
2147
2148         *mode = m;
2149
2150         return PKGMGR_R_OK;
2151 }
2152
2153 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
2154                 const char *pkgid, int *mode, uid_t uid)
2155 {
2156         return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
2157 }
2158
2159 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
2160                 const char *pkgid, int *mode)
2161 {
2162         return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
2163                         _getuid());
2164 }
2165
2166 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
2167                 uid_t uid)
2168 {
2169         GVariant *result;
2170         int ret = PKGMGR_R_ECOMM;
2171         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2172
2173         if (pc == NULL) {
2174                 ERR("invalid parameter");
2175                 return PKGMGR_R_EINVAL;
2176         }
2177
2178         ret = pkgmgr_client_connection_send_request(client,
2179                         "set_restriction_mode",
2180                         g_variant_new("(usi)", uid, "", mode), &result);
2181         if (ret != PKGMGR_R_OK) {
2182                 ERR("request failed: %d", ret);
2183                 return ret;
2184         }
2185
2186         g_variant_get(result, "(i)", &ret);
2187         g_variant_unref(result);
2188
2189         return ret;
2190 }
2191
2192 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
2193 {
2194         return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
2195 }
2196
2197 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
2198                 uid_t uid)
2199 {
2200         GVariant *result;
2201         int ret = PKGMGR_R_ECOMM;
2202         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2203
2204         if (pc == NULL) {
2205                 ERR("invalid parameter");
2206                 return PKGMGR_R_EINVAL;
2207         }
2208
2209         ret = pkgmgr_client_connection_send_request(client,
2210                         "unset_restriction_mode",
2211                         g_variant_new("(usi)", uid, "", mode), &result);
2212         if (ret != PKGMGR_R_OK) {
2213                 ERR("request failed: %d", ret);
2214                 return ret;
2215         }
2216
2217         g_variant_get(result, "(i)", &ret);
2218         g_variant_unref(result);
2219
2220         return ret;
2221 }
2222
2223 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
2224 {
2225         return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
2226 }
2227
2228 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
2229                 int *mode, uid_t uid)
2230 {
2231         GVariant *result;
2232         int ret = PKGMGR_R_ECOMM;
2233         gint m;
2234         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2235
2236         if (pc == NULL) {
2237                 ERR("invalid parameter");
2238                 return PKGMGR_R_EINVAL;
2239         }
2240
2241         ret = pkgmgr_client_connection_send_request(client,
2242                         "get_restriction_mode",
2243                         g_variant_new("(us)", uid, ""), &result);
2244         if (ret != PKGMGR_R_OK) {
2245                 ERR("request failed: %d", ret);
2246                 return ret;
2247         }
2248
2249         g_variant_get(result, "(ii)", &m, &ret);
2250         g_variant_unref(result);
2251         if (ret != PKGMGR_R_OK)
2252                 return ret;
2253
2254         *mode = m;
2255
2256         return PKGMGR_R_OK;
2257 }
2258
2259 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
2260 {
2261         return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
2262 }
2263
2264 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
2265 {
2266         int ret;
2267         pkg_plugin_set *plugin_set;
2268         package_manager_pkg_detail_info_t *info;
2269         char *pkg_type;
2270
2271         if (pkg_path == NULL) {
2272                 ERR("invalid parameter");
2273                 return NULL;
2274         }
2275
2276         pkg_type = __get_type_from_path(pkg_path);
2277         if (pkg_type == NULL) {
2278                 ERR("cannot get pkg type");
2279                 return NULL;
2280         }
2281
2282         plugin_set = _package_manager_load_library(pkg_type);
2283         if (plugin_set == NULL) {
2284                 ERR("failed to load library for %s", pkg_type);
2285                 free(pkg_type);
2286                 return NULL;
2287         }
2288
2289         info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2290         if (info == NULL) {
2291                 ERR("out of memory");
2292                 free(pkg_type);
2293                 return NULL;
2294         }
2295
2296         ret = plugin_set->get_pkg_detail_info_from_package(pkg_path, info);
2297         if (ret) {
2298                 ERR("get_pkg_detail_info_from_package failed");
2299                 free(info);
2300                 free(pkg_type);
2301                 return NULL;
2302         }
2303
2304         free(pkg_type);
2305
2306         return (pkgmgr_info *)info;
2307 }
2308
2309 API int pkgmgr_client_free_pkginfo(pkgmgr_info *info)
2310 {
2311         package_manager_pkg_detail_info_t *pkg_info =
2312                 (package_manager_pkg_detail_info_t *)info;
2313
2314         if (info == NULL) {
2315                 ERR("invalid parameter");
2316                 return PKGMGR_R_EINVAL;
2317         }
2318
2319         g_list_free_full(pkg_info->privilege_list, free);
2320         free(pkg_info->icon_buf);
2321         free(pkg_info);
2322
2323         return PKGMGR_R_OK;
2324 }
2325
2326 API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid,
2327                 char *label, uid_t uid)
2328 {
2329         GVariant *result;
2330         int ret = -1;
2331         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2332
2333         if (pc == NULL || appid == NULL || label == NULL) {
2334                 ERR("Invalid parameter");
2335                 return PKGMGR_R_EINVAL;
2336         }
2337
2338         ret = pkgmgr_client_connection_send_request(client,
2339                         "set_app_label",
2340                         g_variant_new("(uss)", uid, appid, label), &result);
2341         if (ret != PKGMGR_R_OK) {
2342                 ERR("Request failed: %d", ret);
2343                 return ret;
2344         }
2345
2346         g_variant_get(result, "(i)", &ret);
2347         g_variant_unref(result);
2348
2349         return ret;
2350 }
2351
2352 API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label)
2353 {
2354         return pkgmgr_client_usr_set_app_label(pc, appid, label, _getuid());
2355 }
2356
2357 API int pkgmgr_client_usr_set_app_icon(pkgmgr_client *pc, char *appid,
2358                 char *icon_path, uid_t uid)
2359 {
2360         GVariant *result;
2361         int ret = -1;
2362         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2363
2364         if (pc == NULL || appid == NULL || icon_path == NULL) {
2365                 ERR("Invalid parameter");
2366                 return PKGMGR_R_EINVAL;
2367         }
2368
2369         if (access(icon_path, F_OK) != 0) {
2370                 ERR("failed to access: %s", icon_path);
2371                 return PKGMGR_R_EINVAL;
2372         }
2373
2374         ret = pkgmgr_client_connection_send_request(client,
2375                         "set_app_icon",
2376                         g_variant_new("(uss)", uid, appid, icon_path), &result);
2377         if (ret != PKGMGR_R_OK) {
2378                 ERR("Request failed: %d", ret);
2379                 return ret;
2380         }
2381
2382         g_variant_get(result, "(i)", &ret);
2383         g_variant_unref(result);
2384
2385         return ret;
2386 }
2387
2388 API int pkgmgr_client_set_app_icon(pkgmgr_client *pc, char *appid, char *icon_path)
2389 {
2390         return pkgmgr_client_usr_set_app_icon(pc, appid, icon_path, _getuid());
2391 }
2392
2393 API int pkgmgr_client_set_debug_mode(pkgmgr_client *pc, bool debug_mode)
2394 {
2395         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2396
2397         if (pc == NULL) {
2398                 ERR("invalid parameter");
2399                 return PKGMGR_R_EINVAL;
2400         }
2401
2402         client->debug_mode = debug_mode;
2403
2404         return PKGMGR_R_OK;
2405 }
2406
2407 API int pkgmgr_client_set_skip_optimization(pkgmgr_client *pc, bool skip_optimization)
2408 {
2409         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2410
2411         if (pc == NULL) {
2412                 ERR("invalid parameter");
2413                 return PKGMGR_R_EINVAL;
2414         }
2415
2416         client->skip_optimization = skip_optimization;
2417
2418         return PKGMGR_R_OK;
2419 }
2420
2421 API int pkgmgr_client_usr_migrate_external_image(pkgmgr_client *pc,
2422                 const char *pkgid, uid_t uid)
2423 {
2424         GVariant *result;
2425         int ret = PKGMGR_R_ECOMM;
2426         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2427
2428         if (pc == NULL) {
2429                 ERR("invalid parameter");
2430                 return PKGMGR_R_EINVAL;
2431         }
2432
2433         ret = pkgmgr_client_connection_send_request(client,
2434                         "migrate_external_image",
2435                         g_variant_new("(us)", uid, pkgid), &result);
2436         if (ret != PKGMGR_R_OK) {
2437                 ERR("request failed: %d", ret);
2438                 return ret;
2439         }
2440
2441         g_variant_get(result, "(i)", &ret);
2442         g_variant_unref(result);
2443
2444         return ret;
2445 }