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