client/src/pkgmgr.c

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