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