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