plugin/app2sd/lib/app2sd_client_interface.c

   1 /*
   2  * app2ext
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Garima Shrivastava<garima.s@samsung.com>
   7  *      Jyotsna Dhumale <jyotsna.a@samsung.com>
   8  *      Venkatesha Sarpangala <sarpangala.v@samsung.com>
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  * http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  */
  23
  24 #include <stdio.h>
  25 #include <errno.h>
  26 #include <sys/types.h>
  27 #include <sys/wait.h>
  28 #include <gio/gio.h>
  29
  30 #include <pkgmgr-info.h>
  31 #include <sqlite3.h>
  32 #include <tzplatform_config.h>
  33
  34 #include "app2sd_client_interface.h"
  35 #include "app2sd_utils.h"
  36
  37 #define CONNECTION_RETRY_MAX 5
  38 #define CONNECTION_WAIT_USEC (1000000 / 2) /* 0.5 sec */
  39
  40 static int app2sd_gdbus_shared_connection(GDBusConnection **connection)
  41 {
  42         GError *error = NULL;
  43
  44 #if (GLIB_MAJOR_VERSION <= 2 && GLIB_MINOR_VERSION < 36)
  45         g_type_init();
  46 #endif
  47
  48         *connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
  49         if (*connection == NULL) {
  50                 if (error != NULL) {
  51                         _E("app2sd error : failed to get "
  52                                 "system dbus [%s]", error->message);
  53                         g_error_free(error);
  54                 }
  55                 return APP2EXT_ERROR_DBUS_FAILED;
  56         }
  57
  58         return APP2EXT_SUCCESS;
  59 }
  60
  61 static int __app2sd_call_server_method(const gchar *method_name,
  62                 GVariant *param)
  63 {
  64         int ret = APP2EXT_SUCCESS;
  65         int result = 0;
  66         int retry_cnt = 0;
  67         GDBusConnection *conn = NULL;
  68         GDBusProxy *proxy = NULL;
  69         GError *error = NULL;
  70         GVariant *value = NULL;
  71
  72         /* get gdbus connection */
  73         ret = app2sd_gdbus_shared_connection(&conn);
  74         if (ret) {
  75                 _E("app2sd error : dbus connection error");
  76                 return ret;
  77         }
  78
  79         /* method call */
  80         do {
  81                 proxy = g_dbus_proxy_new_sync(conn,
  82                         G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, NULL,
  83                         APP2SD_BUS_NAME, APP2SD_OBJECT_PATH,
  84                         APP2SD_INTERFACE_NAME,
  85                         NULL, &error);
  86                 if (proxy == NULL) {
  87                         _E("failed to create new proxy, error(%s)",
  88                                 error->message);
  89                         g_error_free(error);
  90                         error = NULL;
  91                         ret = APP2EXT_ERROR_DBUS_FAILED;
  92                         retry_cnt++;
  93                         usleep(CONNECTION_WAIT_USEC);
  94                         continue;
  95                 }
  96
  97                 value = g_dbus_proxy_call_sync(proxy, method_name, param,
  98                         G_DBUS_CALL_FLAGS_NONE, G_MAXINT, NULL, &error);
  99                 g_object_unref(proxy);
 100                 if (error != NULL) {
 101                         _E("proxy call sync error(%s)", error->message);
 102                         g_error_free(error);
 103                         error = NULL;
 104                         ret = APP2EXT_ERROR_DBUS_FAILED;
 105                         retry_cnt++;
 106                         usleep(CONNECTION_WAIT_USEC);
 107                         continue;
 108                 }
 109
 110                 g_variant_get(value, "(i)", &result);
 111                 g_variant_unref(value);
 112
 113                 _D("result(%d)", result);
 114                 if (result)
 115                         ret = result;
 116
 117                 break;
 118         } while (retry_cnt <= CONNECTION_RETRY_MAX);
 119
 120         if (conn)
 121                 g_object_unref(conn);
 122
 123         return ret;
 124 }
 125
 126 static void __app2sd_create_dir_list_builder(gpointer data, gpointer user_data)
 127 {
 128         app2ext_dir_details *item = (app2ext_dir_details *)data;
 129         GVariantBuilder *builder = (GVariantBuilder *)user_data;
 130
 131         g_variant_builder_add(builder, "(si)", item->name, item->type);
 132 }
 133
 134 static int __app2sd_delete_temp_directories(const char *pkgid,
 135                 app2sd_cmd cmd, uid_t uid)
 136 {
 137         int ret = 0;
 138         char app_path[FILENAME_MAX] = { 0, };
 139         char temp_path[FILENAME_MAX] = { 0, };
 140
 141         if (cmd != APP2SD_PRE_UPGRADE)
 142                 return APP2EXT_SUCCESS;
 143
 144         _app2sd_set_application_path(pkgid, uid, app_path, sizeof(app_path));
 145         snprintf(temp_path, sizeof(temp_path), "%s.new", app_path);
 146
 147         /* this will delete all files under temp_path */
 148         ret = _app2sd_delete_directory(temp_path);
 149         if (ret) {
 150                 _E("unable to delete (%s)", temp_path);
 151                 return APP2EXT_ERROR_DELETE_DIRECTORY;
 152         }
 153
 154         return APP2EXT_SUCCESS;
 155 }
 156
 157 static int __app2sd_create_default_directories(const char *pkgid,
 158                 app2sd_cmd cmd, uid_t uid)
 159 {
 160         int ret = 0;
 161         mode_t mode = DIR_PERMS;
 162         char application_path[FILENAME_MAX] = { 0, };
 163         char app_mmc_path[FILENAME_MAX] = { 0, };
 164         char temp_path[FILENAME_MAX] = { 0, };
 165
 166         _app2sd_set_application_path(pkgid, uid, application_path,
 167                 sizeof(application_path));
 168         ret = mkdir(application_path, mode);
 169         if (ret) {
 170                 if (errno != EEXIST) {
 171                         _E("create directory failed," \
 172                                 " error no is (%d)", errno);
 173                         return APP2EXT_ERROR_CREATE_DIRECTORY;
 174                 }
 175         }
 176
 177         snprintf(app_mmc_path, sizeof(app_mmc_path), "%s/.mmc",
 178                 application_path);
 179         ret = mkdir(app_mmc_path, mode);
 180         if (ret) {
 181                 if (errno != EEXIST) {
 182                         _E("create directory failed," \
 183                                 " error no is (%d)", errno);
 184                         return APP2EXT_ERROR_CREATE_DIRECTORY;
 185                 }
 186         }
 187
 188         if (cmd == APP2SD_PRE_UPGRADE) {
 189                 /* application_path for {pkgid}.new */
 190                 snprintf(temp_path, sizeof(temp_path), "%s.new",
 191                         application_path);
 192                 ret = mkdir(temp_path, mode);
 193                 if (ret) {
 194                         if (errno != EEXIST) {
 195                                 _E("create directory failed," \
 196                                         " error no is (%d)", errno);
 197                                 return APP2EXT_ERROR_CREATE_DIRECTORY;
 198                         }
 199                 }
 200                 /* app_mmc_path for {pkgid}.new */
 201                 snprintf(app_mmc_path, sizeof(app_mmc_path), "%s/.mmc",
 202                         temp_path);
 203                 ret = mkdir(app_mmc_path, mode);
 204                 if (ret) {
 205                         if (errno != EEXIST) {
 206                                 _E("create directory failed," \
 207                                         " error no is (%d)", errno);
 208                                 return APP2EXT_ERROR_CREATE_DIRECTORY;
 209                         }
 210                 }
 211         }
 212
 213         return APP2EXT_SUCCESS;
 214 }
 215
 216 int app2sd_client_usr_pre_app_install(const char *pkgid, GList *dir_list,
 217                 int size, uid_t uid)
 218 {
 219         int ret = 0;
 220         GVariantBuilder *builder = NULL;
 221         GVariant *param = NULL;
 222
 223         /* validate the function parameter recieved */
 224         if (pkgid == NULL || dir_list == NULL || size <= 0) {
 225                 _E("invalid function arguments");
 226                 return APP2EXT_ERROR_INVALID_ARGUMENTS;
 227         }
 228
 229         ret = __app2sd_create_default_directories(pkgid,
 230                 APP2SD_PRE_INSTALL, uid);
 231         if (ret)
 232                 return ret;
 233
 234         builder = g_variant_builder_new(G_VARIANT_TYPE("a(si)"));
 235         g_list_foreach(dir_list, __app2sd_create_dir_list_builder, builder);
 236
 237         param = g_variant_new("(sia(si)i)", pkgid, size, builder, uid);
 238         ret = __app2sd_call_server_method("PreAppInstall", param);
 239
 240         if (builder)
 241                 g_variant_builder_unref(builder);
 242
 243         return ret;
 244 }
 245 int app2sd_client_pre_app_install(const char *pkgid, GList *dir_list,
 246                 int size)
 247 {
 248         int ret = 0;
 249
 250         ret = app2sd_client_usr_pre_app_install(pkgid,
 251                 dir_list, size, getuid());
 252
 253         return ret;
 254 }
 255
 256 int app2sd_client_usr_post_app_install(const char *pkgid,
 257                 app2ext_status install_status, uid_t uid)
 258 {
 259         int ret = 0;
 260         GVariant *param = NULL;
 261
 262         /* validate the function parameter recieved */
 263         if (pkgid == NULL || install_status < APP2EXT_STATUS_FAILED
 264                 || install_status > APP2EXT_STATUS_SUCCESS) {
 265                 _E("invalid func parameters");
 266                 return APP2EXT_ERROR_INVALID_ARGUMENTS;
 267         }
 268
 269         param = g_variant_new("(sii)", pkgid, install_status, uid);
 270         ret = __app2sd_call_server_method("PostAppInstall", param);
 271
 272         return ret;
 273 }
 274 int app2sd_client_post_app_install(const char *pkgid,
 275                 app2ext_status install_status)
 276 {
 277         int ret = 0;
 278
 279         ret = app2sd_client_usr_post_app_install(pkgid,
 280                 install_status, getuid());
 281
 282         return ret;
 283 }
 284
 285 int app2sd_client_usr_pre_app_upgrade(const char *pkgid, GList *dir_list,
 286                 int size, uid_t uid)
 287 {
 288         int ret = 0;
 289         GVariantBuilder *builder = NULL;
 290         GVariant *param = NULL;
 291
 292         /* validate the function parameter recieved */
 293         if (pkgid == NULL || dir_list == NULL || size <= 0) {
 294                 _E("invalid function arguments");
 295                 return APP2EXT_ERROR_INVALID_ARGUMENTS;
 296         }
 297
 298         ret = __app2sd_create_default_directories(pkgid,
 299                 APP2SD_PRE_UPGRADE, uid);
 300         if (ret)
 301                 return ret;
 302
 303         builder = g_variant_builder_new(G_VARIANT_TYPE("a(si)"));
 304         g_list_foreach(dir_list, __app2sd_create_dir_list_builder, builder);
 305
 306         param = g_variant_new("(sia(si)i)", pkgid, size, builder, uid);
 307         ret = __app2sd_call_server_method("PreAppUpgrade", param);
 308
 309         if (builder)
 310                 g_variant_builder_unref(builder);
 311
 312         __app2sd_delete_temp_directories(pkgid, APP2SD_PRE_UPGRADE, uid);
 313
 314         return ret;
 315 }
 316 int app2sd_client_pre_app_upgrade(const char *pkgid, GList *dir_list,
 317                 int size)
 318 {
 319         int ret = 0;
 320
 321         ret = app2sd_client_usr_pre_app_upgrade(pkgid,
 322                 dir_list, size, getuid());
 323
 324         return ret;
 325 }
 326
 327 int app2sd_client_usr_post_app_upgrade(const char *pkgid,
 328                 app2ext_status install_status, uid_t uid)
 329 {
 330         int ret = 0;
 331         GVariant *param = NULL;
 332
 333         /* validate the function parameter recieved */
 334         if (pkgid == NULL || install_status < APP2EXT_STATUS_FAILED
 335                 || install_status > APP2EXT_STATUS_SUCCESS) {
 336                 _E("invalid func parameters");
 337                 return APP2EXT_ERROR_INVALID_ARGUMENTS;
 338         }
 339
 340         param = g_variant_new("(sii)", pkgid, install_status, uid);
 341         ret = __app2sd_call_server_method("PostAppUpgrade", param);
 342
 343         return ret;
 344 }
 345 int app2sd_client_post_app_upgrade(const char *pkgid,
 346                 app2ext_status install_status)
 347 {
 348         int ret = 0;
 349
 350         ret = app2sd_client_usr_post_app_upgrade(pkgid,
 351                 install_status, getuid());
 352
 353         return ret;
 354 }
 355
 356 int app2sd_client_usr_pre_app_uninstall(const char *pkgid, uid_t uid)
 357 {
 358         int ret = 0;
 359         GVariant *param = NULL;
 360
 361         /* validate the function parameter recieved */
 362         if (pkgid == NULL) {
 363                 _E("invalid func parameters");
 364                 return APP2EXT_ERROR_INVALID_ARGUMENTS;
 365         }
 366
 367         param = g_variant_new("(si)", pkgid, uid);
 368         ret = __app2sd_call_server_method("PreAppUninstall", param);
 369
 370         return ret;
 371 }
 372 int app2sd_client_pre_app_uninstall(const char *pkgid)
 373 {
 374         int ret = 0;
 375
 376         ret = app2sd_client_usr_pre_app_uninstall(pkgid,
 377                 getuid());
 378
 379         return ret;
 380 }
 381
 382 int app2sd_client_usr_post_app_uninstall(const char *pkgid, uid_t uid)
 383 {
 384         int ret = 0;
 385         GVariant *param = NULL;
 386
 387         /* validate the function parameter recieved */
 388         if (pkgid == NULL) {
 389                 _E("invalid func parameters");
 390                 return APP2EXT_ERROR_INVALID_ARGUMENTS;
 391         }
 392
 393         param = g_variant_new("(si)", pkgid, uid);
 394         ret = __app2sd_call_server_method("PostAppUninstall", param);
 395
 396         return ret;
 397 }
 398 int app2sd_client_post_app_uninstall(const char *pkgid)
 399 {
 400         int ret = 0;
 401
 402         ret = app2sd_client_usr_post_app_uninstall(pkgid,
 403                 getuid());
 404
 405         return ret;
 406 }
 407
 408 int app2sd_client_usr_force_clean(const char *pkgid, uid_t uid)
 409 {
 410         int ret = 0;
 411         GVariant *param = NULL;
 412
 413         /* validate the function parameter recieved */
 414         if (pkgid == NULL) {
 415                 _E("invalid func parameters");
 416                 return APP2EXT_ERROR_INVALID_ARGUMENTS;
 417         }
 418
 419         param = g_variant_new("(si)", pkgid, uid);
 420         ret = __app2sd_call_server_method("ForceClean", param);
 421
 422         return ret;
 423 }
 424 int app2sd_client_force_clean(const char *pkgid)
 425 {
 426         int ret = 0;
 427
 428         ret = app2sd_client_usr_force_clean(pkgid, getuid());
 429
 430         return ret;
 431 }
 432
 433 int app2sd_client_enable_full_pkg(void)
 434 {
 435         int ret = 0;
 436
 437         ret = __app2sd_call_server_method("EnableFullPkg", NULL);
 438
 439         return ret;
 440 }
 441
 442 int app2sd_client_disable_full_pkg(void)
 443 {
 444         int ret = 0;
 445
 446         ret = __app2sd_call_server_method("DisableFullPkg", NULL);
 447
 448         return ret;
 449 }
 450
 451 int app2sd_client_usr_on_demand_setup_init(const char *pkgid, uid_t uid)
 452 {
 453         int ret = 0;
 454         GVariant *param = NULL;
 455
 456         /* validate the function parameter recieved */
 457         if (pkgid == NULL) {
 458                 _E("invalid func parameters");
 459                 return APP2EXT_ERROR_INVALID_ARGUMENTS;
 460         }
 461
 462         param = g_variant_new("(si)", pkgid, uid);
 463         ret = __app2sd_call_server_method("OndemandSetupInit", param);
 464
 465         return ret;
 466 }
 467 int app2sd_client_on_demand_setup_init(const char *pkgid)
 468 {
 469         int ret = 0;
 470
 471         ret = app2sd_client_usr_on_demand_setup_init(pkgid,
 472                 getuid());
 473
 474         return ret;
 475 }
 476
 477 int app2sd_client_usr_on_demand_setup_exit(const char *pkgid, uid_t uid)
 478 {
 479         int ret = 0;
 480         GVariant *param = NULL;
 481
 482         /* validate the function parameter recieved */
 483         if (pkgid == NULL) {
 484                 _E("invalid func parameters");
 485                 return APP2EXT_ERROR_INVALID_ARGUMENTS;
 486         }
 487
 488         param = g_variant_new("(si)", pkgid, uid);
 489         ret = __app2sd_call_server_method("OndemandSetupExit", param);
 490
 491         return ret;
 492 }
 493 int app2sd_client_on_demand_setup_exit(const char *pkgid)
 494 {
 495         int ret = 0;
 496
 497         ret = app2sd_client_usr_on_demand_setup_exit(pkgid,
 498                 getuid());
 499
 500         return ret;
 501 }
 502
 503 int app2sd_client_usr_pre_move_installed_app(const char *pkgid, GList *dir_list,
 504                 app2ext_move_type move_type, uid_t uid)
 505 {
 506         int ret = 0;
 507         GVariantBuilder *builder = NULL;
 508         GVariant *param = NULL;
 509         app2sd_cmd cmd = APP2SD_MOVE_APP_TO_PHONE;
 510         pkgmgrinfo_pkginfo_h info_handle = NULL;
 511         pkgmgrinfo_installed_storage storage = PMINFO_INTERNAL_STORAGE;
 512
 513         /* validate the function parameter recieved */
 514         if (pkgid == NULL || dir_list == NULL
 515                 || move_type < APP2EXT_MOVE_TO_EXT
 516                 || move_type > APP2EXT_MOVE_TO_PHONE) {
 517                 _E("invalid function arguments");
 518                 return APP2EXT_ERROR_INVALID_ARGUMENTS;
 519         }
 520
 521         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &info_handle);
 522         if (ret < 0) {
 523                 _E("failed to get pkginfo for pkg(%s), uid(%d), ret(%d)",
 524                         pkgid, uid, ret);
 525                 return APP2EXT_ERROR_PKGMGR_ERROR;
 526         }
 527         ret = pkgmgrinfo_pkginfo_get_installed_storage(info_handle, &storage);
 528         if (ret < 0) {
 529                 _E("failed to get installed storage for pkg(%s) " \
 530                         "of uid(%d), ret(%d)", pkgid, uid, ret);
 531                 pkgmgrinfo_pkginfo_destroy_pkginfo(info_handle);
 532                 return APP2EXT_ERROR_PKGMGR_ERROR;
 533         }
 534
 535         if ((move_type == APP2EXT_MOVE_TO_EXT && storage ==
 536                         PMINFO_EXTERNAL_STORAGE)
 537                 || (move_type == APP2EXT_MOVE_TO_PHONE &&
 538                         storage == PMINFO_INTERNAL_STORAGE)) {
 539                         _E("PKG_EXISTS in [%d] STORAGE", storage);
 540                         pkgmgrinfo_pkginfo_destroy_pkginfo(info_handle);
 541                         return APP2EXT_ERROR_PKG_EXISTS;
 542         } else {
 543                 _D("pkgid[%s] move to STORAGE [%d]", pkgid, storage);
 544         }
 545         pkgmgrinfo_pkginfo_destroy_pkginfo(info_handle);
 546
 547         if (move_type == APP2EXT_MOVE_TO_EXT)
 548                 cmd = APP2SD_MOVE_APP_TO_MMC;
 549
 550         if (cmd == APP2SD_MOVE_APP_TO_MMC) {
 551                 ret = __app2sd_create_default_directories(pkgid, cmd, uid);
 552                 if (ret)
 553                         return ret;
 554         }
 555
 556         builder = g_variant_builder_new(G_VARIANT_TYPE("a(si)"));
 557         g_list_foreach(dir_list, __app2sd_create_dir_list_builder, builder);
 558
 559         param = g_variant_new("(sia(si)i)", pkgid, move_type, builder, uid);
 560         ret = __app2sd_call_server_method("PreMoveInstalledApp", param);
 561
 562         if (builder)
 563                 g_variant_builder_unref(builder);
 564
 565         return ret;
 566 }
 567 int app2sd_client_pre_move_installed_app(const char *pkgid, GList *dir_list,
 568                 app2ext_move_type move_type)
 569 {
 570         int ret = 0;
 571
 572         ret = app2sd_client_usr_pre_move_installed_app(pkgid,
 573                 dir_list, move_type, getuid());
 574
 575         return ret;
 576 }
 577
 578 int app2sd_client_usr_post_move_installed_app(const char *pkgid,
 579                 app2ext_move_type move_type, uid_t uid)
 580 {
 581         int ret = 0;
 582         GVariant *param = NULL;
 583
 584         /* validate the function parameter recieved */
 585         if (pkgid == NULL || move_type < APP2EXT_MOVE_TO_EXT
 586                 || move_type > APP2EXT_MOVE_TO_PHONE) {
 587                 _E("invalid function arguments");
 588                 return APP2EXT_ERROR_INVALID_ARGUMENTS;
 589         }
 590
 591         param = g_variant_new("(sii)", pkgid, move_type, uid);
 592         ret = __app2sd_call_server_method("PostMoveInstalledApp", param);
 593
 594         return ret;
 595 }
 596 int app2sd_client_post_move_installed_app(const char *pkgid,
 597                 app2ext_move_type move_type)
 598 {
 599         int ret = 0;
 600
 601         ret = app2sd_client_usr_post_move_installed_app(pkgid,
 602                 move_type, getuid());
 603
 604         return ret;
 605 }
 606
 607 int app2sd_client_usr_pre_migrate_legacy(const char *pkgid, uid_t uid)
 608 {
 609         int ret = 0;
 610         GVariant *param = NULL;
 611
 612         /* validate the function parameter recieved */
 613         if (pkgid == NULL) {
 614                 _E("invalid function arguments");
 615                 return APP2EXT_ERROR_INVALID_ARGUMENTS;
 616         }
 617
 618         param = g_variant_new("(si)", pkgid, uid);
 619         ret = __app2sd_call_server_method("PreMigrateLegacy", param);
 620
 621         return ret;
 622 }
 623
 624 int app2sd_client_usr_post_migrate_legacy(const char *pkgid, uid_t uid)
 625 {
 626         int ret = 0;
 627         GVariant *param = NULL;
 628
 629         /* validate the function parameter recieved */
 630         if (pkgid == NULL) {
 631                 _E("invalid function arguments");
 632                 return APP2EXT_ERROR_INVALID_ARGUMENTS;
 633         }
 634
 635         param = g_variant_new("(si)", pkgid, uid);
 636         ret = __app2sd_call_server_method("PostMigrateLegacy", param);
 637
 638         return ret;
 639 }
 640
 641 int app2sd_client_migrate_legacy_all()
 642 {
 643         int ret = 0;
 644
 645         ret = __app2sd_call_server_method("MigrateLegacyAll", NULL);
 646
 647         return ret;
 648 }
 649
 650 char *app2sd_client_usr_getname_image(const char *pkgid, uid_t uid)
 651 {
 652         return _app2sd_get_encoded_name(pkgid, uid);
 653 }
 654
 655 char *app2sd_client_usr_get_image_path(const char *pkgid, uid_t uid)
 656 {
 657         static const char query[] =
 658                 "SELECT filename FROM app2sd_info WHERE pkgid=? AND uid=?";
 659         int ret;
 660         sqlite3 *db;
 661         sqlite3_stmt *stmt;
 662         const char *dbpath;
 663         char *image_path = NULL;
 664
 665         dbpath = tzplatform_mkpath(TZ_SYS_DB, ".app2sd.db");
 666         if (dbpath == NULL)
 667                 return NULL;
 668
 669         ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
 670         if (ret != SQLITE_OK) {
 671                 LOGE("open failed: %s", sqlite3_errmsg(db));
 672                 return NULL;
 673         }
 674
 675         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 676         if (ret != SQLITE_OK) {
 677                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 678                 sqlite3_close_v2(db);
 679                 return NULL;
 680         }
 681
 682         ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC);
 683         if (ret != SQLITE_OK) {
 684                 LOGE("bind failed: %s", sqlite3_errmsg(db));
 685                 sqlite3_finalize(stmt);
 686                 sqlite3_close_v2(db);
 687                 return NULL;
 688         }
 689
 690         ret = sqlite3_bind_int(stmt, 2, uid);
 691         if (ret != SQLITE_OK) {
 692                 LOGE("bind failed: %s", sqlite3_errmsg(db));
 693                 sqlite3_finalize(stmt);
 694                 sqlite3_close_v2(db);
 695                 return NULL;
 696         }
 697
 698         ret = sqlite3_step(stmt);
 699         if (ret == SQLITE_ROW)
 700                 image_path = strdup((char *)sqlite3_column_text(stmt, 0));
 701
 702         sqlite3_finalize(stmt);
 703         sqlite3_close_v2(db);
 704
 705         return image_path;
 706 }
 707
 708 void app2ext_on_load(app2ext_interface *interface)
 709 {
 710         /* Plug-in Binding.*/
 711         interface->client_pre_install = app2sd_client_pre_app_install;
 712         interface->client_post_install = app2sd_client_post_app_install;
 713         interface->client_pre_upgrade = app2sd_client_pre_app_upgrade;
 714         interface->client_post_upgrade = app2sd_client_post_app_upgrade;
 715         interface->client_pre_uninstall = app2sd_client_pre_app_uninstall;
 716         interface->client_post_uninstall = app2sd_client_post_app_uninstall;
 717         interface->client_force_clean = app2sd_client_force_clean;
 718         interface->client_enable = app2sd_client_on_demand_setup_init;
 719         interface->client_disable = app2sd_client_on_demand_setup_exit;
 720         interface->client_enable_full_pkg = app2sd_client_enable_full_pkg;
 721         interface->client_disable_full_pkg = app2sd_client_disable_full_pkg;
 722         interface->client_pre_move = app2sd_client_pre_move_installed_app;
 723         interface->client_post_move = app2sd_client_post_move_installed_app;
 724         interface->client_migrate_legacy_all = app2sd_client_migrate_legacy_all;
 725
 726         interface->client_usr_pre_install = app2sd_client_usr_pre_app_install;
 727         interface->client_usr_post_install = app2sd_client_usr_post_app_install;
 728         interface->client_usr_pre_upgrade = app2sd_client_usr_pre_app_upgrade;
 729         interface->client_usr_post_upgrade = app2sd_client_usr_post_app_upgrade;
 730         interface->client_usr_pre_uninstall = app2sd_client_usr_pre_app_uninstall;
 731         interface->client_usr_post_uninstall = app2sd_client_usr_post_app_uninstall;
 732         interface->client_usr_force_clean = app2sd_client_usr_force_clean;
 733         interface->client_usr_enable = app2sd_client_usr_on_demand_setup_init;
 734         interface->client_usr_disable = app2sd_client_usr_on_demand_setup_exit;
 735         interface->client_usr_pre_move = app2sd_client_usr_pre_move_installed_app;
 736         interface->client_usr_post_move = app2sd_client_usr_post_move_installed_app;
 737         interface->client_usr_getname_image = app2sd_client_usr_getname_image;
 738         interface->client_usr_pre_migrate_legacy = app2sd_client_usr_pre_migrate_legacy;
 739         interface->client_usr_post_migrate_legacy = app2sd_client_usr_post_migrate_legacy;
 740         interface->client_usr_get_image_path = app2sd_client_usr_get_image_path;
 741 }