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_activate(pkgmgr_client *pc, const char *pkg_type,
 764                 const char *pkgid, uid_t uid)
 765 {
 766         GVariant *result;
 767         int ret = PKGMGR_R_ECOMM;
 768         GVariantBuilder *builder;
 769         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 770
 771         if (pc == NULL || pkgid == NULL) {
 772                 ERR("invalid parameter");
 773                 return PKGMGR_R_EINVAL;
 774         }
 775
 776         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 777         g_variant_builder_add(builder, "s", pkgid);
 778
 779         ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
 780                         g_variant_new("(uas)", uid, builder), &result);
 781         g_variant_builder_unref(builder);
 782         if (ret != PKGMGR_R_OK) {
 783                 ERR("request failed: %d", ret);
 784                 return ret;
 785         }
 786
 787         g_variant_get(result, "(is)", &ret, NULL);
 788         g_variant_unref(result);
 789
 790         return ret;
 791 }
 792
 793 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
 794                 const char *pkgid)
 795 {
 796         return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, _getuid());
 797 }
 798
 799 API int pkgmgr_client_usr_activate_packages(pkgmgr_client *pc,
 800                 const char *pkg_type, const char **pkgids, int n_pkgs,
 801                 pkgmgr_handler event_cb, void *data, uid_t uid)
 802 {
 803         GVariant *result;
 804         GVariantBuilder *builder;
 805         int ret = PKGMGR_R_ECOMM;
 806         char *req_key = NULL;
 807         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 808         struct cb_info *cb_info;
 809         int i;
 810
 811         if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
 812                 ERR("invalid parameter");
 813                 return PKGMGR_R_EINVAL;
 814         }
 815
 816         if (client->pc_type != PC_REQUEST) {
 817                 ERR("client type is not PC_REQUEST");
 818                 return PKGMGR_R_EINVAL;
 819         }
 820
 821         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 822         for (i = 0; i < n_pkgs; i++)
 823                 g_variant_builder_add(builder, "s", pkgids[i]);
 824
 825         ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
 826                         g_variant_new("(uas)", uid, builder), &result);
 827         g_variant_builder_unref(builder);
 828         if (ret != PKGMGR_R_OK) {
 829                 ERR("request failed: %d", ret);
 830                 return ret;
 831         }
 832
 833         g_variant_get(result, "(i&s)", &ret, &req_key);
 834         if (req_key == NULL) {
 835                 g_variant_unref(result);
 836                 return PKGMGR_R_ECOMM;
 837         }
 838         if (ret != PKGMGR_R_OK) {
 839                 g_variant_unref(result);
 840                 return ret;
 841         }
 842
 843         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
 844         if (cb_info == NULL) {
 845                 g_variant_unref(result);
 846                 return PKGMGR_R_ERROR;
 847         }
 848         g_variant_unref(result);
 849         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 850         if (ret != PKGMGR_R_OK) {
 851                 __free_cb_info(cb_info);
 852                 return ret;
 853         }
 854         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 855
 856         return cb_info->req_id;
 857 }
 858
 859 API int pkgmgr_client_activate_packages(pkgmgr_client *pc,
 860                 const char *pkg_type, const char **pkgids, int n_pkgs,
 861                 pkgmgr_handler event_cb, void *data)
 862 {
 863         return pkgmgr_client_usr_activate_packages(pc, pkg_type,
 864                         pkgids, n_pkgs, event_cb, data, _getuid());
 865 }
 866
 867 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
 868                                  const char *pkgid, uid_t uid)
 869 {
 870         GVariant *result;
 871         GVariantBuilder *builder;
 872         int ret = PKGMGR_R_ECOMM;
 873         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 874
 875         if (pc == NULL || pkgid == NULL) {
 876                 ERR("invalid parameter");
 877                 return PKGMGR_R_EINVAL;
 878         }
 879
 880         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 881         g_variant_builder_add(builder, "s", pkgid);
 882
 883         ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
 884                         g_variant_new("(uas)", uid, builder), &result);
 885         g_variant_builder_unref(builder);
 886         if (ret != PKGMGR_R_OK) {
 887                 ERR("request failed: %d", ret);
 888                 return ret;
 889         }
 890
 891         g_variant_get(result, "(is)", &ret, NULL);
 892         g_variant_unref(result);
 893
 894         return ret;
 895 }
 896
 897 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
 898                                  const char *pkgid)
 899 {
 900         return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, _getuid());
 901 }
 902
 903 API int pkgmgr_client_usr_deactivate_packages(pkgmgr_client *pc,
 904                 const char *pkg_type, const char **pkgids, int n_pkgs,
 905                 pkgmgr_handler event_cb, void *data, uid_t uid)
 906 {
 907         GVariant *result;
 908         GVariantBuilder *builder;
 909         int ret = PKGMGR_R_ECOMM;
 910         char *req_key = NULL;
 911         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 912         struct cb_info *cb_info;
 913         int i;
 914
 915         if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
 916                 ERR("invalid parameter");
 917                 return PKGMGR_R_EINVAL;
 918         }
 919
 920         if (client->pc_type != PC_REQUEST) {
 921                 ERR("client type is not PC_REQUEST");
 922                 return PKGMGR_R_EINVAL;
 923         }
 924
 925         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
 926         for (i = 0; i < n_pkgs; i++)
 927                 g_variant_builder_add(builder, "s", pkgids[i]);
 928
 929         ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
 930                 g_variant_new("(uas)", uid, builder), &result);
 931         g_variant_builder_unref(builder);
 932         if (ret != PKGMGR_R_OK) {
 933                 ERR("request failed: %d", ret);
 934                 return ret;
 935         }
 936
 937         g_variant_get(result, "(i&s)", &ret, &req_key);
 938         if (req_key == NULL) {
 939                 g_variant_unref(result);
 940                 return PKGMGR_R_ECOMM;
 941         }
 942         if (ret != PKGMGR_R_OK) {
 943                 g_variant_unref(result);
 944                 return ret;
 945         }
 946
 947         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
 948         if (cb_info == NULL) {
 949                 g_variant_unref(result);
 950                 return PKGMGR_R_ERROR;
 951         }
 952         g_variant_unref(result);
 953         ret = pkgmgr_client_connection_set_callback(client, cb_info);
 954         if (ret != PKGMGR_R_OK) {
 955                 __free_cb_info(cb_info);
 956                 return ret;
 957         }
 958         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
 959
 960         return cb_info->req_id;
 961 }
 962
 963 API int pkgmgr_client_deactivate_packages(pkgmgr_client *pc,
 964                 const char *pkg_type, const char **pkgids, int n_pkgs,
 965                 pkgmgr_handler event_cb, void *data)
 966 {
 967         return pkgmgr_client_usr_deactivate_packages(pc, pkg_type,
 968                         pkgids, n_pkgs, event_cb, data, _getuid());
 969 }
 970
 971 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
 972                 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
 973 {
 974         GVariant *result;
 975         int ret = PKGMGR_R_ECOMM;
 976         char *req_key = NULL;
 977         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
 978         struct cb_info *cb_info;
 979
 980         if (pc == NULL || appid == NULL) {
 981                 ERR("invalid parameter");
 982                 return PKGMGR_R_EINVAL;
 983         }
 984
 985         ret = pkgmgr_client_connection_send_request(client, "enable_app",
 986                         g_variant_new("(us)", uid, appid), &result);
 987         if (ret != PKGMGR_R_OK) {
 988                 ERR("request failed: %d", ret);
 989                 return ret;
 990         }
 991
 992         g_variant_get(result, "(i&s)", &ret, &req_key);
 993         if (req_key == NULL) {
 994                 g_variant_unref(result);
 995                 return PKGMGR_R_ECOMM;
 996         }
 997         if (ret != PKGMGR_R_OK) {
 998                 g_variant_unref(result);
 999                 return ret;
1000         }
1001
1002         cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1003                         req_key);
1004         if (cb_info == NULL) {
1005                 g_variant_unref(result);
1006                 return PKGMGR_R_ENOMEM;
1007         }
1008         g_variant_unref(result);
1009         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1010         if (ret != PKGMGR_R_OK) {
1011                 __free_cb_info(cb_info);
1012                 return ret;
1013         }
1014         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1015
1016         return cb_info->req_id;
1017 }
1018
1019 API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid,
1020                 pkgmgr_app_handler app_event_cb, void *data)
1021 {
1022         return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb,
1023                         data, _getuid());
1024 }
1025
1026 API int pkgmgr_client_usr_activate_apps(pkgmgr_client *pc, const char **appids,
1027                 int n_apps, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1028 {
1029         GVariant *result;
1030         GVariantBuilder *builder;
1031         int ret = PKGMGR_R_ECOMM;
1032         char *req_key = NULL;
1033         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1034         struct cb_info *cb_info;
1035         int i;
1036
1037         if (pc == NULL || appids == NULL || n_apps < 1) {
1038                 ERR("invalid parameter");
1039                 return PKGMGR_R_EINVAL;
1040         }
1041
1042         if (client->pc_type != PC_REQUEST) {
1043                 ERR("client type is not PC_REQUEST");
1044                 return PKGMGR_R_EINVAL;
1045         }
1046
1047         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1048         for (i = 0; i < n_apps; i++)
1049                 g_variant_builder_add(builder, "s", appids[i]);
1050
1051         ret = pkgmgr_client_connection_send_request(client, "enable_apps",
1052                 g_variant_new("(uas)", uid, builder), &result);
1053         g_variant_builder_unref(builder);
1054         if (ret != PKGMGR_R_OK) {
1055                 ERR("request failed: %d", ret);
1056                 return ret;
1057         }
1058
1059         g_variant_get(result, "(i&s)", &ret, &req_key);
1060         if (req_key == NULL) {
1061                 g_variant_unref(result);
1062                 return PKGMGR_R_ECOMM;
1063         }
1064         if (ret != PKGMGR_R_OK) {
1065                 g_variant_unref(result);
1066                 return ret;
1067         }
1068
1069         cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
1070         if (cb_info == NULL) {
1071                 g_variant_unref(result);
1072                 return PKGMGR_R_ERROR;
1073         }
1074         g_variant_unref(result);
1075         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1076         if (ret != PKGMGR_R_OK) {
1077                 __free_cb_info(cb_info);
1078                 return ret;
1079         }
1080         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1081
1082         return cb_info->req_id;
1083 }
1084
1085 API int pkgmgr_client_activate_apps(pkgmgr_client *pc, const char **appids,
1086                 int n_apps, pkgmgr_app_handler app_event_cb, void *data)
1087 {
1088         return pkgmgr_client_usr_activate_apps(pc, appids, n_apps,
1089                         app_event_cb, data, _getuid());
1090 }
1091
1092 API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
1093                 const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1094 {
1095         GVariant *result;
1096         int ret = PKGMGR_R_ECOMM;
1097         char *req_key = NULL;
1098         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1099         struct cb_info *cb_info;
1100
1101         if (pc == NULL || appid == NULL) {
1102                 ERR("invalid parameter");
1103                 return PKGMGR_R_EINVAL;
1104         }
1105
1106         ret = pkgmgr_client_connection_send_request(client,
1107                         "enable_global_app_for_uid",
1108                         g_variant_new("(us)", uid, appid), &result);
1109         if (ret != PKGMGR_R_OK) {
1110                 ERR("request failed: %d", ret);
1111                 return ret;
1112         }
1113
1114         g_variant_get(result, "(i&s)", &ret, &req_key);
1115         if (req_key == NULL) {
1116                 g_variant_unref(result);
1117                 return PKGMGR_R_ECOMM;
1118         }
1119         if (ret != PKGMGR_R_OK) {
1120                 g_variant_unref(result);
1121                 return ret;
1122         }
1123
1124         cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1125                         req_key);
1126         if (cb_info == NULL) {
1127                 g_variant_unref(result);
1128                 return PKGMGR_R_ENOMEM;
1129         }
1130         g_variant_unref(result);
1131         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1132         if (ret != PKGMGR_R_OK) {
1133                 __free_cb_info(cb_info);
1134                 return ret;
1135         }
1136         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1137
1138         return cb_info->req_id;
1139 }
1140
1141 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1142                 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1143 {
1144         GVariant *result;
1145         int ret = PKGMGR_R_ECOMM;
1146         char *req_key = NULL;
1147         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1148         struct cb_info *cb_info;
1149
1150         if (pc == NULL || appid == NULL) {
1151                 ERR("invalid parameter");
1152                 return PKGMGR_R_EINVAL;
1153         }
1154
1155         ret = pkgmgr_client_connection_send_request(client, "disable_app",
1156                         g_variant_new("(us)", uid, appid), &result);
1157         if (ret != PKGMGR_R_OK) {
1158                 ERR("request failed: %d", ret);
1159                 return ret;
1160         }
1161
1162         g_variant_get(result, "(i&s)", &ret, &req_key);
1163         if (req_key == NULL) {
1164                 g_variant_unref(result);
1165                 return PKGMGR_R_ECOMM;
1166         }
1167         if (ret != PKGMGR_R_OK) {
1168                 g_variant_unref(result);
1169                 return ret;
1170         }
1171
1172         cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1173                         req_key);
1174         if (cb_info == NULL) {
1175                 g_variant_unref(result);
1176                 return PKGMGR_R_ENOMEM;
1177         }
1178         g_variant_unref(result);
1179         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1180         if (ret != PKGMGR_R_OK) {
1181                 __free_cb_info(cb_info);
1182                 return ret;
1183         }
1184         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1185
1186         return cb_info->req_id;
1187 }
1188
1189 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid,
1190                 pkgmgr_app_handler app_event_cb, void *data)
1191 {
1192         return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb, data,
1193                         _getuid());
1194 }
1195
1196 API int pkgmgr_client_usr_deactivate_apps(pkgmgr_client *pc,
1197                 const char **appids, int n_apps,
1198                 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1199 {
1200         GVariant *result;
1201         GVariantBuilder *builder;
1202         int ret = PKGMGR_R_ECOMM;
1203         char *req_key = NULL;
1204         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1205         struct cb_info *cb_info;
1206         int i;
1207
1208         if (pc == NULL || appids == NULL || n_apps < 1) {
1209                 ERR("invalid parameter");
1210                 return PKGMGR_R_EINVAL;
1211         }
1212
1213         if (client->pc_type != PC_REQUEST) {
1214                 ERR("client type is not PC_REQUEST");
1215                 return PKGMGR_R_EINVAL;
1216         }
1217
1218         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1219         for (i = 0; i < n_apps; i++)
1220                 g_variant_builder_add(builder, "s", appids[i]);
1221
1222         ret = pkgmgr_client_connection_send_request(client, "disable_apps",
1223                 g_variant_new("(uas)", uid, builder), &result);
1224         g_variant_builder_unref(builder);
1225         if (ret != PKGMGR_R_OK) {
1226                 ERR("request failed: %d", ret);
1227                 return ret;
1228         }
1229
1230         g_variant_get(result, "(i&s)", &ret, &req_key);
1231         if (req_key == NULL) {
1232                 g_variant_unref(result);
1233                 return PKGMGR_R_ECOMM;
1234         }
1235         if (ret != PKGMGR_R_OK) {
1236                 g_variant_unref(result);
1237                 return ret;
1238         }
1239
1240         cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
1241         if (cb_info == NULL) {
1242                 g_variant_unref(result);
1243                 return PKGMGR_R_ERROR;
1244         }
1245         g_variant_unref(result);
1246         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1247         if (ret != PKGMGR_R_OK) {
1248                 __free_cb_info(cb_info);
1249                 return ret;
1250         }
1251         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1252
1253         return cb_info->req_id;
1254 }
1255
1256 API int pkgmgr_client_deactivate_apps(pkgmgr_client *pc, const char **appids,
1257                 int n_apps, pkgmgr_app_handler app_event_cb, void *data)
1258 {
1259         return pkgmgr_client_usr_deactivate_apps(pc, appids, n_apps,
1260                         app_event_cb, data, _getuid());
1261 }
1262
1263 API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
1264                 const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1265 {
1266         GVariant *result;
1267         int ret = PKGMGR_R_ECOMM;
1268         char *req_key = NULL;
1269         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1270         struct cb_info *cb_info;
1271
1272         if (pc == NULL || appid == NULL) {
1273                 ERR("invalid parameter");
1274                 return PKGMGR_R_EINVAL;
1275         }
1276
1277         ret = pkgmgr_client_connection_send_request(client,
1278                         "disable_global_app_for_uid",
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_usr_clear_user_data(pkgmgr_client *pc,
1313                 const char *pkg_type, const char *appid, pkgmgr_mode mode,
1314                 uid_t uid)
1315 {
1316         GVariant *result;
1317         int ret;
1318         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1319
1320         if (pc == NULL || appid == NULL || uid == GLOBAL_USER) {
1321                 ERR("invalid parameter");
1322                 return PKGMGR_R_EINVAL;
1323         }
1324
1325         if (client->pc_type != PC_REQUEST) {
1326                 ERR("client->pc_type is not PC_REQUEST");
1327                 return PKGMGR_R_EINVAL;
1328         }
1329
1330         ret = pkgmgr_client_connection_send_request(client, "cleardata",
1331                         g_variant_new("(us)", uid, appid), &result);
1332         if (ret != PKGMGR_R_OK) {
1333                 ERR("request failed: %d", ret);
1334                 return ret;
1335         }
1336
1337         g_variant_get(result, "(i)", &ret);
1338         g_variant_unref(result);
1339
1340         return ret;
1341 }
1342
1343 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1344                 const char *appid, pkgmgr_mode mode)
1345 {
1346         return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid, mode,
1347                         _getuid());
1348 }
1349
1350 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1351 {
1352         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1353
1354         if (pc == NULL) {
1355                 ERR("invalid parameter");
1356                 return PKGMGR_R_EINVAL;
1357         }
1358
1359         client->status_type = status_type;
1360
1361         return PKGMGR_R_OK;
1362 }
1363
1364 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1365                 void *data)
1366 {
1367         int ret;
1368         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1369         struct cb_info *cb_info;
1370
1371         if (pc == NULL || event_cb == NULL) {
1372                 ERR("invalid parameter");
1373                 return PKGMGR_R_EINVAL;
1374         }
1375
1376         if (client->pc_type != PC_LISTENING) {
1377                 ERR("client->pc_type is not PC_LISTENING");
1378                 return PKGMGR_R_EINVAL;
1379         }
1380
1381         cb_info = __create_event_cb_info(client, event_cb, data, NULL);
1382         if (cb_info == NULL)
1383                 return PKGMGR_R_ENOMEM;
1384         cb_info->status_type = client->status_type;
1385         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1386         if (ret != PKGMGR_R_OK) {
1387                 __free_cb_info(cb_info);
1388                 return ret;
1389         }
1390         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1391
1392         return cb_info->req_id;
1393 }
1394
1395 API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
1396                 pkgmgr_app_handler app_event_cb, void *data)
1397 {
1398         int ret;
1399         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1400         struct cb_info *cb_info;
1401
1402         if (pc == NULL || app_event_cb == NULL) {
1403                 ERR("invalid parameter");
1404                 return PKGMGR_R_EINVAL;
1405         }
1406
1407         if (client->pc_type != PC_LISTENING) {
1408                 ERR("client->pc_type is not PC_LISTENING");
1409                 return PKGMGR_R_EINVAL;
1410         }
1411
1412         cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL);
1413         if (cb_info == NULL)
1414                 return PKGMGR_R_ENOMEM;
1415         cb_info->status_type = client->status_type;
1416         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1417         if (ret != PKGMGR_R_OK) {
1418                 __free_cb_info(cb_info);
1419                 return ret;
1420         }
1421         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1422
1423         return cb_info->req_id;
1424 }
1425
1426 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
1427 {
1428         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1429         GList *tmp;
1430         GList *next;
1431         struct cb_info *cb_info;
1432
1433         if (pc == NULL) {
1434                 ERR("invalid parameter");
1435                 return PKGMGR_R_EINVAL;
1436         }
1437
1438         /* unset all callback */
1439         tmp = client->cb_info_list;
1440         while (tmp != NULL) {
1441                 next = tmp->next;
1442                 cb_info = (struct cb_info *)tmp->data;
1443                 pkgmgr_client_connection_unset_callback(pc, cb_info);
1444                 client->cb_info_list = g_list_delete_link(client->cb_info_list,
1445                                 tmp);
1446                 __free_cb_info(cb_info);
1447                 tmp = next;
1448         }
1449
1450         return PKGMGR_R_OK;
1451 }
1452
1453 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1454                 const char *pkgid, const char *key, const char *val)
1455 {
1456         /* client cannot broadcast signal */
1457         return PKGMGR_R_OK;
1458 }
1459
1460 /* TODO: deprecate(or remove) */
1461 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
1462                 int service_mode, pkgmgr_client *pc, const char *pkg_type,
1463                 const char *pkgid, const char *custom_info,
1464                 pkgmgr_handler event_cb, void *data)
1465 {
1466         return pkgmgr_client_usr_request_service(service_type, service_mode,
1467                         pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
1468                         data);
1469 }
1470
1471 API int pkgmgr_client_usr_request_service(
1472                 pkgmgr_request_service_type service_type, int service_mode,
1473                 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
1474                 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
1475                 void *data)
1476 {
1477         int ret = 0;
1478
1479         /* Check for NULL value of service type */
1480         retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1481         retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1482
1483         switch (service_type) {
1484         case PM_REQUEST_MOVE:
1485                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1486                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1487                 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1488
1489                 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1490                 break;
1491
1492         case PM_REQUEST_GET_SIZE:
1493                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1494                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1495                 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1496
1497                 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1498                 break;
1499
1500         case PM_REQUEST_KILL_APP:
1501         case PM_REQUEST_CHECK_APP:
1502                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1503                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1504
1505                 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1506                 if (ret < 0)
1507                         ERR("__check_app_process fail \n");
1508                 else
1509                         ret = PKGMGR_R_OK;
1510
1511                 break;
1512
1513         default:
1514                 ERR("Wrong Request\n");
1515                 ret = -1;
1516                 break;
1517         }
1518
1519 catch:
1520
1521         return ret;
1522 }
1523
1524
1525 API int pkgmgr_client_usr_request_size_info(uid_t uid)
1526 {
1527         int ret;
1528         struct pkgmgr_client *client;
1529
1530         client = pkgmgr_client_new(PC_REQUEST);
1531         if (client == NULL) {
1532                 ERR("out of memory");
1533                 return PKGMGR_R_ENOMEM;
1534         }
1535
1536         ret = __request_size_info(client, uid);
1537         if (ret < 0)
1538                 ERR("__request_size_info fail");
1539
1540         pkgmgr_client_free(client);
1541         return ret;
1542 }
1543
1544 API int pkgmgr_client_request_size_info(void)
1545 {
1546         /* get all package size (data, total) */
1547         return pkgmgr_client_usr_request_size_info(_getuid());
1548 }
1549
1550 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1551 {
1552         GVariant *result;
1553         int ret;
1554         struct pkgmgr_client_t *client;
1555
1556         if (pkgid == NULL || uid == GLOBAL_USER) {
1557                 ERR("invalid parameter");
1558                 return PKGMGR_R_EINVAL;
1559         }
1560
1561         client = pkgmgr_client_new(PC_REQUEST);
1562         if (client == NULL) {
1563                 ERR("out of memory");
1564                 return PKGMGR_R_ENOMEM;
1565         }
1566
1567         ret = pkgmgr_client_connection_send_request(client, "clearcache",
1568                         g_variant_new("(us)", uid, pkgid), &result);
1569         if (ret != PKGMGR_R_OK) {
1570                 ERR("request failed: %d", ret);
1571                 return ret;
1572         }
1573
1574         g_variant_get(result, "(i)", &ret);
1575         g_variant_unref(result);
1576
1577         return ret;
1578 }
1579
1580 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1581 {
1582         return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
1583 }
1584
1585 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1586 {
1587         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1588 }
1589
1590 API int pkgmgr_client_clear_all_cache_dir(void)
1591 {
1592         return pkgmgr_client_usr_clear_cache_dir(
1593                         PKG_CLEAR_ALL_CACHE, _getuid());
1594 }
1595
1596 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
1597                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1598                 void *data)
1599 {
1600         return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
1601                         _getuid());
1602 }
1603
1604 /* TODO: deprecate(or remove) */
1605 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
1606                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1607                 void *data, uid_t uid)
1608 {
1609         GVariant *result;
1610         int ret = PKGMGR_R_ECOMM;
1611         char *req_key = NULL;
1612         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1613         struct cb_info *cb_info;
1614
1615         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1616                 ERR("invalid parameter");
1617                 return PKGMGR_R_EINVAL;
1618         }
1619
1620         if (client->pc_type != PC_REQUEST) {
1621                 ERR("client->pc_type is not PC_REQUEST");
1622                 return PKGMGR_R_EINVAL;
1623         }
1624
1625         /* FIXME */
1626         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1627                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1628         else
1629                 get_type = PM_GET_PKG_SIZE_INFO;
1630
1631         ret = pkgmgr_client_connection_send_request(client, "getsize",
1632                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
1633         if (ret != PKGMGR_R_OK) {
1634                 ERR("request failed: %d", ret);
1635                 return ret;
1636         }
1637
1638         g_variant_get(result, "(i&s)", &ret, &req_key);
1639         if (req_key == NULL) {
1640                 g_variant_unref(result);
1641                 return PKGMGR_R_ECOMM;
1642         }
1643         if (ret != PKGMGR_R_OK) {
1644                 g_variant_unref(result);
1645                 return ret;
1646         }
1647
1648         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1649         if (cb_info == NULL) {
1650                 g_variant_unref(result);
1651                 return PKGMGR_R_ENOMEM;
1652         }
1653         g_variant_unref(result);
1654         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1655         if (ret != PKGMGR_R_OK) {
1656                 __free_cb_info(cb_info);
1657                 return ret;
1658         }
1659         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1660
1661         return PKGMGR_R_OK;
1662 }
1663
1664 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
1665                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1666                 void *user_data, uid_t uid)
1667 {
1668         GVariant *result;
1669         int ret = PKGMGR_R_ECOMM;
1670         char *req_key = NULL;
1671         int get_type;
1672         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1673         struct cb_info *cb_info;
1674
1675         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1676                 ERR("invalid parameter");
1677                 return PKGMGR_R_EINVAL;
1678         }
1679
1680         if (client->pc_type != PC_REQUEST) {
1681                 ERR("client->pc_type is not PC_REQUEST");
1682                 return PKGMGR_R_EINVAL;
1683         }
1684
1685         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1686                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1687         else
1688                 get_type = PM_GET_PKG_SIZE_INFO;
1689
1690         ret = pkgmgr_client_connection_send_request(client, "getsize",
1691                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
1692         if (ret != PKGMGR_R_OK) {
1693                 ERR("request failed: %d", ret);
1694                 return ret;
1695         }
1696
1697         g_variant_get(result, "(i&s)", &ret, &req_key);
1698         if (req_key == NULL) {
1699                 g_variant_unref(result);
1700                 return PKGMGR_R_ECOMM;
1701         }
1702         if (ret != PKGMGR_R_OK) {
1703                 g_variant_unref(result);
1704                 return ret;
1705         }
1706
1707         cb_info = __create_size_info_cb_info(client, event_cb, user_data,
1708                         req_key);
1709         if (cb_info == NULL) {
1710                 g_variant_unref(result);
1711                 return PKGMGR_R_ENOMEM;
1712         }
1713         g_variant_unref(result);
1714         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1715         if (ret != PKGMGR_R_OK) {
1716                 __free_cb_info(cb_info);
1717                 return ret;
1718         }
1719         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1720
1721         return PKGMGR_R_OK;
1722 }
1723
1724 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
1725                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1726                 void *user_data)
1727 {
1728         return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
1729                         user_data, _getuid());
1730 }
1731
1732 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
1733                 pkgmgr_total_pkg_size_info_receive_cb event_cb,
1734                 void *user_data, uid_t uid)
1735 {       /* total package size info */
1736         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1737                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
1738                         user_data, uid);
1739 }
1740
1741 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
1742                 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
1743 {
1744         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1745                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
1746                         user_data, _getuid());
1747 }
1748
1749 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
1750                 const char *resp_data, char **req_data, char **license_url)
1751 {
1752         GVariant *result;
1753         int ret;
1754         char *data;
1755         char *url;
1756         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1757
1758         if (pc == NULL || resp_data == NULL || req_data == NULL ||
1759                         license_url == NULL) {
1760                 ERR("invalid parameter");
1761                 return PKGMGR_R_EINVAL;
1762         }
1763
1764         if (client->pc_type != PC_REQUEST) {
1765                 ERR("client->pc_type is not PC_REQUEST");
1766                 return PKGMGR_R_EINVAL;
1767         }
1768
1769         ret = pkgmgr_client_connection_send_request(client,
1770                         "generate_license_request",
1771                         g_variant_new("(s)", resp_data), &result);
1772         if (ret != PKGMGR_R_OK) {
1773                 ERR("request failed: %d", ret);
1774                 return ret;
1775         }
1776
1777         g_variant_get(result, "(i&s&s)", &ret, &data, &url);
1778         if (ret != PKGMGR_R_OK) {
1779                 ERR("generate_license_request failed: %d", ret);
1780                 g_variant_unref(result);
1781                 return ret;
1782         }
1783
1784         *req_data = strdup(data);
1785         *license_url = strdup(url);
1786
1787         g_variant_unref(result);
1788
1789         return PKGMGR_R_OK;
1790 }
1791
1792 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
1793 {
1794         GVariant *result;
1795         int ret;
1796         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1797
1798         if (pc == NULL || resp_data == 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         ret = pkgmgr_client_connection_send_request(client, "register_license",
1809                         g_variant_new("(s)", resp_data), &result);
1810         if (ret != PKGMGR_R_OK) {
1811                 ERR("request failed: %d", ret);
1812                 return ret;
1813         }
1814
1815         g_variant_get(result, "(i)", &ret);
1816         g_variant_unref(result);
1817         if (ret != PKGMGR_R_OK)
1818                 ERR("register license failed: %d", ret);
1819
1820         return ret;
1821 }
1822
1823 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
1824                 const char *drm_file_path, const char *decrypted_file_path)
1825 {
1826         GVariant *result;
1827         int ret;
1828         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1829
1830         if (pc == NULL || drm_file_path == NULL ||
1831                         decrypted_file_path == NULL) {
1832                 ERR("invalid parameter");
1833                 return PKGMGR_R_EINVAL;
1834         }
1835
1836         if (client->pc_type != PC_REQUEST) {
1837                 ERR("client->pc_type is not PC_REQUEST");
1838                 return PKGMGR_R_EINVAL;
1839         }
1840
1841         ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
1842                         g_variant_new("(ss)", drm_file_path,
1843                                 decrypted_file_path), &result);
1844         if (ret != PKGMGR_R_OK) {
1845                 ERR("request failed: %d", ret);
1846                 return ret;
1847         }
1848
1849         g_variant_get(result, "(i)", &ret);
1850         g_variant_unref(result);
1851         if (ret != PKGMGR_R_OK)
1852                 ERR("decrypt_package failed: %d", ret);
1853
1854         return ret;
1855 }
1856
1857 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
1858 {
1859         return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
1860 }
1861
1862 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
1863                 const char *appid, uid_t uid)
1864 {
1865         int ret;
1866         GVariant *result;
1867         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1868
1869         if (pc == NULL || appid == NULL) {
1870                 ERR("Invalid parameter");
1871                 return PKGMGR_R_EINVAL;
1872         }
1873
1874         ret = pkgmgr_client_connection_send_request(client,
1875                         "enable_app_splash_screen",
1876                         g_variant_new("(us)", uid, appid), &result);
1877         if (ret != PKGMGR_R_OK) {
1878                 ERR("request failed: %d", ret);
1879                 return ret;
1880         }
1881
1882         g_variant_get(result, "(i)", &ret);
1883         g_variant_unref(result);
1884         if (ret != PKGMGR_R_OK)
1885                 ERR("enable splash screen failed: %d", ret);
1886
1887         return ret;
1888 }
1889
1890 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
1891                 const char *appid)
1892 {
1893         return pkgmgr_client_usr_disable_splash_screen(pc, appid,
1894                         _getuid());
1895 }
1896
1897 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
1898                 const char *appid, uid_t uid)
1899 {
1900         int ret;
1901         GVariant *result;
1902         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1903
1904         if (pc == NULL || appid == NULL) {
1905                 ERR("Invalid parameter");
1906                 return PKGMGR_R_EINVAL;
1907         }
1908
1909         ret = pkgmgr_client_connection_send_request(client,
1910                         "disable_app_splash_screen",
1911                         g_variant_new("(us)", uid, appid), &result);
1912         if (ret != PKGMGR_R_OK) {
1913                 ERR("request failed: %d", ret);
1914                 return ret;
1915         }
1916
1917         g_variant_get(result, "(i)", &ret);
1918         g_variant_unref(result);
1919         if (ret != PKGMGR_R_OK)
1920                 ERR("disable splash screen failed: %d", ret);
1921
1922         return ret;
1923 }
1924
1925 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1926                 int mode, uid_t uid)
1927 {
1928         GVariant *result;
1929         int ret = PKGMGR_R_ECOMM;
1930         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1931
1932         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1933                 ERR("invalid parameter");
1934                 return PKGMGR_R_EINVAL;
1935         }
1936
1937         ret = pkgmgr_client_connection_send_request(client,
1938                         "set_restriction_mode",
1939                         g_variant_new("(usi)", uid, pkgid, mode), &result);
1940         if (ret != PKGMGR_R_OK) {
1941                 ERR("request failed: %d", ret);
1942                 return ret;
1943         }
1944
1945         g_variant_get(result, "(i)", &ret);
1946         g_variant_unref(result);
1947
1948         return ret;
1949 }
1950
1951 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
1952                 const char *pkgid, int mode, uid_t uid)
1953 {
1954         return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
1955 }
1956
1957 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
1958                 const char *pkgid, int mode)
1959 {
1960         return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
1961                         _getuid());
1962 }
1963
1964 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1965                 int mode, uid_t uid)
1966 {
1967         GVariant *result;
1968         int ret = PKGMGR_R_ECOMM;
1969         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1970
1971         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1972                 ERR("invalid parameter");
1973                 return PKGMGR_R_EINVAL;
1974         }
1975
1976         ret = pkgmgr_client_connection_send_request(client,
1977                         "unset_restriction_mode",
1978                         g_variant_new("(usi)", uid, pkgid, mode), &result);
1979         if (ret != PKGMGR_R_OK) {
1980                 ERR("request failed: %d", ret);
1981                 return ret;
1982         }
1983
1984         g_variant_get(result, "(i)", &ret);
1985         g_variant_unref(result);
1986
1987         return ret;
1988
1989 }
1990
1991 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
1992                 const char *pkgid, int mode, uid_t uid)
1993 {
1994         return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
1995 }
1996
1997 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
1998                 const char *pkgid, int mode)
1999 {
2000         return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
2001                         _getuid());
2002 }
2003
2004 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2005                 int *mode, uid_t uid)
2006 {
2007         GVariant *result;
2008         int ret = PKGMGR_R_ECOMM;
2009         gint m;
2010         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2011
2012         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
2013                 ERR("invalid parameter");
2014                 return PKGMGR_R_EINVAL;
2015         }
2016
2017         ret = pkgmgr_client_connection_send_request(client,
2018                         "get_restriction_mode",
2019                         g_variant_new("(us)", uid, pkgid), &result);
2020         if (ret != PKGMGR_R_OK) {
2021                 ERR("request failed: %d", ret);
2022                 return ret;
2023         }
2024
2025         g_variant_get(result, "(ii)", &m, &ret);
2026         g_variant_unref(result);
2027         if (ret != PKGMGR_R_OK)
2028                 return ret;
2029
2030         *mode = m;
2031
2032         return PKGMGR_R_OK;
2033 }
2034
2035 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
2036                 const char *pkgid, int *mode, uid_t uid)
2037 {
2038         return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
2039 }
2040
2041 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
2042                 const char *pkgid, int *mode)
2043 {
2044         return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
2045                         _getuid());
2046 }
2047
2048 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
2049                 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) {
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, "", 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_set_restriction_mode(pkgmgr_client *pc, int mode)
2075 {
2076         return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
2077 }
2078
2079 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
2080                 uid_t uid)
2081 {
2082         GVariant *result;
2083         int ret = PKGMGR_R_ECOMM;
2084         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2085
2086         if (pc == NULL) {
2087                 ERR("invalid parameter");
2088                 return PKGMGR_R_EINVAL;
2089         }
2090
2091         ret = pkgmgr_client_connection_send_request(client,
2092                         "unset_restriction_mode",
2093                         g_variant_new("(usi)", uid, "", mode), &result);
2094         if (ret != PKGMGR_R_OK) {
2095                 ERR("request failed: %d", ret);
2096                 return ret;
2097         }
2098
2099         g_variant_get(result, "(i)", &ret);
2100         g_variant_unref(result);
2101
2102         return ret;
2103 }
2104
2105 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
2106 {
2107         return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
2108 }
2109
2110 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
2111                 int *mode, uid_t uid)
2112 {
2113         GVariant *result;
2114         int ret = PKGMGR_R_ECOMM;
2115         gint m;
2116         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2117
2118         if (pc == NULL) {
2119                 ERR("invalid parameter");
2120                 return PKGMGR_R_EINVAL;
2121         }
2122
2123         ret = pkgmgr_client_connection_send_request(client,
2124                         "get_restriction_mode",
2125                         g_variant_new("(us)", uid, ""), &result);
2126         if (ret != PKGMGR_R_OK) {
2127                 ERR("request failed: %d", ret);
2128                 return ret;
2129         }
2130
2131         g_variant_get(result, "(ii)", &m, &ret);
2132         g_variant_unref(result);
2133         if (ret != PKGMGR_R_OK)
2134                 return ret;
2135
2136         *mode = m;
2137
2138         return PKGMGR_R_OK;
2139 }
2140
2141 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
2142 {
2143         return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
2144 }
2145
2146 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
2147 {
2148         int ret;
2149         pkg_plugin_set *plugin_set;
2150         package_manager_pkg_detail_info_t *info;
2151         char *pkg_type;
2152
2153         if (pkg_path == NULL) {
2154                 ERR("invalid parameter");
2155                 return NULL;
2156         }
2157
2158         pkg_type = __get_type_from_path(pkg_path);
2159         if (pkg_type == NULL) {
2160                 ERR("cannot get pkg type");
2161                 return NULL;
2162         }
2163
2164         plugin_set = _package_manager_load_library(pkg_type);
2165         if (plugin_set == NULL) {
2166                 ERR("failed to load library for %s", pkg_type);
2167                 free(pkg_type);
2168                 return NULL;
2169         }
2170
2171         info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2172         if (info == NULL) {
2173                 ERR("out of memory");
2174                 free(pkg_type);
2175                 return NULL;
2176         }
2177
2178         ret = plugin_set->get_pkg_detail_info_from_package(pkg_path, info);
2179         if (ret) {
2180                 ERR("get_pkg_detail_info_from_package failed");
2181                 free(info);
2182                 free(pkg_type);
2183                 return NULL;
2184         }
2185
2186         free(pkg_type);
2187
2188         return (pkgmgr_info *)info;
2189 }
2190
2191 API int pkgmgr_client_free_pkginfo(pkgmgr_info *info)
2192 {
2193         package_manager_pkg_detail_info_t *pkg_info =
2194                 (package_manager_pkg_detail_info_t *)info;
2195
2196         if (info == NULL) {
2197                 ERR("invalid parameter");
2198                 return PKGMGR_R_EINVAL;
2199         }
2200
2201         free(pkg_info->icon_buf);
2202         free(pkg_info);
2203
2204         return PKGMGR_R_OK;
2205 }
2206
2207 API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid,
2208                 char *label, uid_t uid)
2209 {
2210         GVariant *result;
2211         int ret = -1;
2212         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2213
2214         if (pc == NULL || appid == NULL || label == NULL) {
2215                 ERR("Invalid parameter");
2216                 return PKGMGR_R_EINVAL;
2217         }
2218
2219         ret = pkgmgr_client_connection_send_request(client,
2220                         "set_app_label",
2221                         g_variant_new("(uss)", uid, appid, label), &result);
2222         if (ret != PKGMGR_R_OK) {
2223                 ERR("Request failed: %d", ret);
2224                 return ret;
2225         }
2226
2227         g_variant_get(result, "(i)", &ret);
2228         g_variant_unref(result);
2229
2230         return ret;
2231 }
2232
2233 API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label)
2234 {
2235         return pkgmgr_client_usr_set_app_label(pc, appid, label, _getuid());
2236 }
2237
2238 API int pkgmgr_client_set_debug_mode(pkgmgr_client *pc, bool debug_mode)
2239 {
2240         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2241
2242         if (pc == NULL) {
2243                 ERR("invalid parameter");
2244                 return PKGMGR_R_EINVAL;
2245         }
2246
2247         client->debug_mode = debug_mode;
2248
2249         return PKGMGR_R_OK;
2250 }
2251
2252 API int pkgmgr_client_usr_migrate_external_image(pkgmgr_client *pc,
2253                 const char *pkgid, uid_t uid)
2254 {
2255         GVariant *result;
2256         int ret = PKGMGR_R_ECOMM;
2257         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2258
2259         if (pc == NULL) {
2260                 ERR("invalid parameter");
2261                 return PKGMGR_R_EINVAL;
2262         }
2263
2264         ret = pkgmgr_client_connection_send_request(client,
2265                         "migrate_external_image",
2266                         g_variant_new("(us)", uid, pkgid), &result);
2267         if (ret != PKGMGR_R_OK) {
2268                 ERR("request failed: %d", ret);
2269                 return ret;
2270         }
2271
2272         g_variant_get(result, "(i)", &ret);
2273         g_variant_unref(result);
2274
2275         return ret;
2276 }