src/pkgmgrinfo_certinfo.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <stdbool.h>
   5 #include <unistd.h>
   6 #include <sys/types.h>
   7
   8 #include <sqlite3.h>
   9 #include <glib.h>
  10
  11 #include "pkgmgr-info.h"
  12 #include "pkgmgrinfo_debug.h"
  13 #include "pkgmgrinfo_private.h"
  14 #include "pkgmgr_parser.h"
  15
  16 API int pkgmgrinfo_pkginfo_create_certinfo(pkgmgrinfo_certinfo_h *handle) {
  17   retvm_if(handle == NULL, PMINFO_R_EINVAL,
  18            "Argument supplied to hold return value is NULL\n");
  19   pkgmgr_certinfo_x *certinfo = NULL;
  20   certinfo = calloc(1, sizeof(pkgmgr_certinfo_x));
  21   *handle = NULL;
  22   retvm_if(certinfo == NULL, PMINFO_R_ERROR, "Malloc Failed\n");
  23   *handle = (void *)certinfo;
  24   return PMINFO_R_OK;
  25 }
  26
  27 static int _pkginfo_compare_certinfo(
  28     sqlite3 *db, const char *l_pkgid, const char *r_pkgid,
  29     pkgmgrinfo_cert_compare_result_type_e *result) {
  30   static const char query[] =
  31       "SELECT COALESCE(author_signer_cert, -1) FROM package_cert_info "
  32       "WHERE package=?";
  33   int ret;
  34   sqlite3_stmt *stmt;
  35   const char *pkgid[2];
  36   int certid[2] = {-1, -1};
  37   int i;
  38
  39   pkgid[0] = l_pkgid;
  40   pkgid[1] = r_pkgid;
  41
  42   ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
  43   if (ret != SQLITE_OK) {
  44     _LOGE("prepare error: %s", sqlite3_errmsg(db));
  45     return PMINFO_R_ERROR;
  46   }
  47
  48   for (i = 0; i < 2; i++) {
  49     ret = sqlite3_bind_text(stmt, 1, pkgid[i], -1, SQLITE_STATIC);
  50     if (ret != SQLITE_OK) {
  51       _LOGE("bind error: %s", sqlite3_errmsg(db));
  52       sqlite3_finalize(stmt);
  53       return PMINFO_R_ERROR;
  54     }
  55
  56     ret = sqlite3_step(stmt);
  57     if (ret == SQLITE_ROW) {
  58       _save_column_int(stmt, 0, &certid[i]);
  59     } else if (ret != SQLITE_DONE) {
  60       _LOGE("step error: %s", sqlite3_errmsg(db));
  61       sqlite3_finalize(stmt);
  62       return PMINFO_R_ERROR;
  63     }
  64
  65     sqlite3_reset(stmt);
  66     sqlite3_clear_bindings(stmt);
  67   }
  68
  69   if (certid[0] == -1 && certid[1] == -1)
  70     *result = PMINFO_CERT_COMPARE_BOTH_NO_CERT;
  71   else if (certid[0] == -1)
  72     *result = PMINFO_CERT_COMPARE_LHS_NO_CERT;
  73   else if (certid[1] == -1)
  74     *result = PMINFO_CERT_COMPARE_RHS_NO_CERT;
  75   else if (certid[0] == certid[1])
  76     *result = PMINFO_CERT_COMPARE_MATCH;
  77   else
  78     *result = PMINFO_CERT_COMPARE_MISMATCH;
  79
  80   sqlite3_finalize(stmt);
  81   return PMINFO_R_OK;
  82 }
  83
  84 API int pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(
  85     const char *lhs_package_id, const char *rhs_package_id, uid_t uid,
  86     pkgmgrinfo_cert_compare_result_type_e *compare_result) {
  87   int ret;
  88   sqlite3 *db;
  89   char *dbpath;
  90
  91   if (lhs_package_id == NULL || rhs_package_id == NULL ||
  92       compare_result == NULL) {
  93     _LOGE("invalid parameter");
  94     return PMINFO_R_EINVAL;
  95   }
  96
  97   /* open unified global cert db */
  98   dbpath = getUserPkgCertDBPath();
  99   if (dbpath == NULL) return PMINFO_R_ERROR;
 100
 101   ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY);
 102   if (ret != SQLITE_OK) {
 103     _LOGE("failed to open db: %d", ret);
 104     free(dbpath);
 105     return PMINFO_R_ERROR;
 106   }
 107   free(dbpath);
 108
 109   if (_pkginfo_compare_certinfo(db, lhs_package_id, rhs_package_id,
 110                                 compare_result)) {
 111     _LOGE("failed to compare certinfo");
 112     sqlite3_close_v2(db);
 113     return PMINFO_R_ERROR;
 114   }
 115
 116   sqlite3_close_v2(db);
 117
 118   return PMINFO_R_OK;
 119 }
 120
 121 API int pkgmgrinfo_pkginfo_compare_pkg_cert_info(
 122     const char *lhs_package_id, const char *rhs_package_id,
 123     pkgmgrinfo_cert_compare_result_type_e *compare_result) {
 124   return pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(
 125       lhs_package_id, rhs_package_id, _getuid(), compare_result);
 126 }
 127
 128 static int _pkginfo_get_pkgid_from_appid(uid_t uid, const char *appid,
 129                                          char **pkgid) {
 130   static const char query[] =
 131       "SELECT package FROM package_app_info WHERE app_id=?";
 132   int ret;
 133   sqlite3 *db;
 134   char *dbpath;
 135   sqlite3_stmt *stmt;
 136
 137   dbpath = getUserPkgParserDBPathUID(uid);
 138   if (dbpath == NULL) return PMINFO_R_ERROR;
 139
 140   ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY);
 141   if (ret != SQLITE_OK) {
 142     _LOGE("failed to open db: %d", ret);
 143     free(dbpath);
 144     return PMINFO_R_ERROR;
 145   }
 146   free(dbpath);
 147
 148   ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 149   if (ret != SQLITE_OK) {
 150     _LOGE("prepare error: %s", sqlite3_errmsg(db));
 151     sqlite3_close_v2(db);
 152     return PMINFO_R_ERROR;
 153   }
 154
 155   ret = sqlite3_bind_text(stmt, 1, appid, -1, SQLITE_STATIC);
 156   if (ret != SQLITE_OK) {
 157     _LOGE("bind error: %s", sqlite3_errmsg(db));
 158     sqlite3_finalize(stmt);
 159     sqlite3_close_v2(db);
 160     return PMINFO_R_ERROR;
 161   }
 162
 163   ret = sqlite3_step(stmt);
 164   if (ret == SQLITE_ROW) {
 165     _save_column_str(stmt, 0, pkgid);
 166     ret = PMINFO_R_OK;
 167   } else if (ret == SQLITE_DONE) {
 168     _LOGI("cannot find pkgid of app %s for uid %d", appid, (int)uid);
 169     ret = PMINFO_R_ENOENT;
 170   } else {
 171     _LOGE("step error: %s", sqlite3_errmsg(db));
 172     ret = PMINFO_R_ERROR;
 173   }
 174
 175   sqlite3_finalize(stmt);
 176   sqlite3_close_v2(db);
 177
 178   return ret;
 179 }
 180
 181 API int pkgmgrinfo_pkginfo_compare_usr_app_cert_info(
 182     const char *lhs_app_id, const char *rhs_app_id, uid_t uid,
 183     pkgmgrinfo_cert_compare_result_type_e *compare_result) {
 184   int ret;
 185   char *l_pkgid = NULL;
 186   char *r_pkgid = NULL;
 187
 188   if (lhs_app_id == NULL || rhs_app_id == NULL || compare_result == NULL) {
 189     _LOGE("invalid parameter");
 190     return PMINFO_R_EINVAL;
 191   }
 192
 193   ret = _pkginfo_get_pkgid_from_appid(uid, lhs_app_id, &l_pkgid);
 194   if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
 195     ret = _pkginfo_get_pkgid_from_appid(GLOBAL_USER, lhs_app_id, &l_pkgid);
 196
 197   if (ret != PMINFO_R_OK) return ret;
 198
 199   ret = _pkginfo_get_pkgid_from_appid(uid, rhs_app_id, &r_pkgid);
 200   if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
 201     ret = _pkginfo_get_pkgid_from_appid(GLOBAL_USER, rhs_app_id, &r_pkgid);
 202
 203   if (ret != PMINFO_R_OK) {
 204     free(l_pkgid);
 205     return ret;
 206   }
 207
 208   ret = pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(l_pkgid, r_pkgid, uid,
 209                                                      compare_result);
 210
 211   free(l_pkgid);
 212   free(r_pkgid);
 213
 214   return ret;
 215 }
 216
 217 API int pkgmgrinfo_pkginfo_compare_app_cert_info(
 218     const char *lhs_app_id, const char *rhs_app_id,
 219     pkgmgrinfo_cert_compare_result_type_e *compare_result) {
 220   return pkgmgrinfo_pkginfo_compare_usr_app_cert_info(
 221       lhs_app_id, rhs_app_id, _getuid(), compare_result);
 222 }
 223
 224 static int _pkginfo_get_cert(sqlite3 *db, int cert_id[], char *cert_info[]) {
 225   static const char query[] =
 226       "SELECT cert_info FROM package_cert_index_info WHERE cert_id=?";
 227   int ret;
 228   sqlite3_stmt *stmt;
 229   int i;
 230
 231   ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 232   if (ret != SQLITE_OK) {
 233     _LOGE("prepare failed: %s", sqlite3_errmsg(db));
 234     return PMINFO_R_ERROR;
 235   }
 236
 237   for (i = 0; i < MAX_CERT_TYPE; i++) {
 238     ret = sqlite3_bind_int(stmt, 1, cert_id[i]);
 239     if (ret != SQLITE_OK) {
 240       sqlite3_finalize(stmt);
 241       _LOGE("bind failed: %s", sqlite3_errmsg(db));
 242       return PMINFO_R_ERROR;
 243     }
 244
 245     ret = sqlite3_step(stmt);
 246     if (ret == SQLITE_DONE) {
 247       sqlite3_reset(stmt);
 248       sqlite3_clear_bindings(stmt);
 249       continue;
 250     } else if (ret != SQLITE_ROW) {
 251       _LOGE("step failed: %s", sqlite3_errmsg(db));
 252       sqlite3_finalize(stmt);
 253       return PMINFO_R_ERROR;
 254     }
 255
 256     _save_column_str(stmt, 0, &cert_info[i]);
 257     sqlite3_reset(stmt);
 258     sqlite3_clear_bindings(stmt);
 259   }
 260
 261   sqlite3_finalize(stmt);
 262
 263   return PMINFO_R_OK;
 264 }
 265
 266 static int _pkginfo_get_certid(sqlite3 *db, const char *pkgid, int cert_id[]) {
 267   static const char query[] =
 268       "SELECT author_root_cert, author_im_cert, author_signer_cert, "
 269       "dist_root_cert, dist_im_cert, dist_signer_cert, "
 270       "dist2_root_cert, dist2_im_cert, dist2_signer_cert "
 271       "FROM package_cert_info WHERE package=?";
 272   int ret;
 273   sqlite3_stmt *stmt;
 274   int idx;
 275
 276   ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 277   if (ret != SQLITE_OK) {
 278     _LOGE("prepare failed: %s", sqlite3_errmsg(db));
 279     return PMINFO_R_ERROR;
 280   }
 281
 282   ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC);
 283   if (ret != SQLITE_OK) {
 284     _LOGE("bind failed: %s", sqlite3_errmsg(db));
 285     sqlite3_finalize(stmt);
 286     return PMINFO_R_ERROR;
 287   }
 288
 289   ret = sqlite3_step(stmt);
 290   if (ret == SQLITE_DONE) {
 291     sqlite3_finalize(stmt);
 292     return PMINFO_R_ENOENT;
 293   } else if (ret != SQLITE_ROW) {
 294     _LOGE("step failed: %s", sqlite3_errmsg(db));
 295     sqlite3_finalize(stmt);
 296     return PMINFO_R_ERROR;
 297   }
 298
 299   idx = 0;
 300   _save_column_int(stmt, idx++, &cert_id[PMINFO_AUTHOR_ROOT_CERT]);
 301   _save_column_int(stmt, idx++, &cert_id[PMINFO_AUTHOR_INTERMEDIATE_CERT]);
 302   _save_column_int(stmt, idx++, &cert_id[PMINFO_AUTHOR_SIGNER_CERT]);
 303   _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR_ROOT_CERT]);
 304   _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR_INTERMEDIATE_CERT]);
 305   _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR_SIGNER_CERT]);
 306   _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR2_ROOT_CERT]);
 307   _save_column_int(stmt, idx++,
 308                    &cert_id[PMINFO_DISTRIBUTOR2_INTERMEDIATE_CERT]);
 309   _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR2_SIGNER_CERT]);
 310
 311   sqlite3_finalize(stmt);
 312
 313   return PMINFO_R_OK;
 314 }
 315
 316 static int _pkginfo_get_certinfo(const char *pkgid, pkgmgr_certinfo_x *info) {
 317   int ret;
 318   sqlite3 *db;
 319   char *dbpath;
 320
 321   /* open unified global cert db */
 322   dbpath = getUserPkgCertDBPath();
 323   if (dbpath == NULL) return PMINFO_R_ERROR;
 324
 325   ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY);
 326   if (ret != SQLITE_OK) {
 327     _LOGE("failed to open db: %d", ret);
 328     free(dbpath);
 329     return PMINFO_R_ERROR;
 330   }
 331   free(dbpath);
 332
 333   ret = _pkginfo_get_certid(db, pkgid, info->cert_id);
 334   if (ret != PMINFO_R_OK) {
 335     sqlite3_close_v2(db);
 336     return ret;
 337   }
 338
 339   ret = _pkginfo_get_cert(db, info->cert_id, info->cert_info);
 340   if (ret != PMINFO_R_OK) {
 341     sqlite3_close_v2(db);
 342     return ret;
 343   }
 344
 345   sqlite3_close_v2(db);
 346
 347   return PMINFO_R_OK;
 348 }
 349
 350 API int pkgmgrinfo_pkginfo_load_certinfo(const char *pkgid,
 351                                          pkgmgrinfo_certinfo_h handle,
 352                                          uid_t uid) {
 353   int ret;
 354   pkgmgr_certinfo_x *info = (pkgmgr_certinfo_x *)handle;
 355
 356   if (pkgid == NULL || handle == NULL) {
 357     _LOGE("invalid parameter");
 358     return PMINFO_R_EINVAL;
 359   }
 360
 361   ret = _pkginfo_get_certinfo(pkgid, info);
 362   if (ret != PMINFO_R_OK) _LOGE("failed to get certinfo of %s ", pkgid);
 363
 364   return ret;
 365 }
 366
 367 API int pkgmgrinfo_pkginfo_get_cert_value(pkgmgrinfo_certinfo_h handle,
 368                                           pkgmgrinfo_cert_type cert_type,
 369                                           const char **cert_value) {
 370   retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
 371   retvm_if(cert_value == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
 372   retvm_if(cert_type < PMINFO_AUTHOR_ROOT_CERT, PMINFO_R_EINVAL,
 373            "Invalid certificate type\n");
 374   retvm_if(cert_type > PMINFO_DISTRIBUTOR2_SIGNER_CERT, PMINFO_R_EINVAL,
 375            "Invalid certificate type\n");
 376   pkgmgr_certinfo_x *certinfo = NULL;
 377   certinfo = (pkgmgr_certinfo_x *)handle;
 378   if ((certinfo->cert_info)[cert_type])
 379     *cert_value = (certinfo->cert_info)[cert_type];
 380   else
 381     *cert_value = NULL;
 382   return PMINFO_R_OK;
 383 }
 384
 385 API int pkgmgrinfo_pkginfo_destroy_certinfo(pkgmgrinfo_certinfo_h handle) {
 386   retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
 387   int i = 0;
 388   pkgmgr_certinfo_x *certinfo = NULL;
 389   certinfo = (pkgmgr_certinfo_x *)handle;
 390   if (certinfo->pkgid) {
 391     free(certinfo->pkgid);
 392     certinfo->pkgid = NULL;
 393   }
 394   for (i = 0; i < MAX_CERT_TYPE; i++) {
 395     if ((certinfo->cert_info)[i]) {
 396       free((certinfo->cert_info)[i]);
 397       (certinfo->cert_info)[i] = NULL;
 398     }
 399   }
 400   free(certinfo);
 401   certinfo = NULL;
 402   return PMINFO_R_OK;
 403 }
 404
 405 API int pkgmgrinfo_create_certinfo_set_handle(
 406     pkgmgrinfo_instcertinfo_h *handle) {
 407   retvm_if(handle == NULL, PMINFO_R_EINVAL,
 408            "Argument supplied to hold return value is NULL\n");
 409   pkgmgr_certinfo_x *certinfo = NULL;
 410   *handle = NULL;
 411   certinfo = calloc(1, sizeof(pkgmgr_certinfo_x));
 412   retvm_if(certinfo == NULL, PMINFO_R_ERROR, "Malloc Failed\n");
 413   *handle = (void *)certinfo;
 414   return PMINFO_R_OK;
 415 }
 416
 417 API int pkgmgrinfo_set_cert_value(pkgmgrinfo_instcertinfo_h handle,
 418                                   pkgmgrinfo_instcert_type cert_type,
 419                                   char *cert_value) {
 420   retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
 421   retvm_if(cert_value == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
 422   retvm_if(cert_type < PMINFO_SET_AUTHOR_ROOT_CERT, PMINFO_R_EINVAL,
 423            "Invalid certificate type\n");
 424   retvm_if(cert_type > PMINFO_SET_DISTRIBUTOR2_SIGNER_CERT, PMINFO_R_EINVAL,
 425            "Invalid certificate type\n");
 426   pkgmgr_certinfo_x *certinfo = NULL;
 427   certinfo = (pkgmgr_certinfo_x *)handle;
 428   if (certinfo->cert_info[cert_type]) free(certinfo->cert_info[cert_type]);
 429   (certinfo->cert_info)[cert_type] = strdup(cert_value);
 430   return PMINFO_R_OK;
 431 }
 432
 433 static int _pkginfo_save_cert_info(sqlite3 *db, const char *pkgid,
 434                                    char *cert_info[]) {
 435   static const char query_insert[] =
 436       "INSERT INTO package_cert_info (package, package_count,"
 437       " author_root_cert, author_im_cert, author_signer_cert,"
 438       " dist_root_cert, dist_im_cert, dist_signer_cert,"
 439       " dist2_root_cert, dist2_im_cert, dist2_signer_cert) "
 440       "VALUES(?, 1,"
 441       " (SELECT cert_id FROM package_cert_index_info"
 442       "  WHERE cert_info=?),"
 443       " (SELECT cert_id FROM package_cert_index_info"
 444       "  WHERE cert_info=?),"
 445       " (SELECT cert_id FROM package_cert_index_info"
 446       "  WHERE cert_info=?),"
 447       " (SELECT cert_id FROM package_cert_index_info"
 448       "  WHERE cert_info=?),"
 449       " (SELECT cert_id FROM package_cert_index_info"
 450       "  WHERE cert_info=?),"
 451       " (SELECT cert_id FROM package_cert_index_info"
 452       "  WHERE cert_info=?),"
 453       " (SELECT cert_id FROM package_cert_index_info"
 454       "  WHERE cert_info=?),"
 455       " (SELECT cert_id FROM package_cert_index_info"
 456       "  WHERE cert_info=?),"
 457       " (SELECT cert_id FROM package_cert_index_info"
 458       "  WHERE cert_info=?))";
 459   static const char query_update[] =
 460       "UPDATE package_cert_info "
 461       "SET package_count = package_count + 1 "
 462       "WHERE package=?";
 463   int ret;
 464   sqlite3_stmt *stmt;
 465   int i;
 466   int idx;
 467
 468   ret = sqlite3_prepare_v2(db, query_insert, strlen(query_insert), &stmt, NULL);
 469   if (ret != SQLITE_OK) {
 470     _LOGE("prepare error: %s", sqlite3_errmsg(db));
 471     return PMINFO_R_ERROR;
 472   }
 473
 474   idx = 1;
 475   ret = sqlite3_bind_text(stmt, idx++, pkgid, -1, SQLITE_STATIC);
 476   if (ret != SQLITE_OK) {
 477     _LOGE("bind failed: %s", sqlite3_errmsg(db));
 478     sqlite3_finalize(stmt);
 479     return PMINFO_R_ERROR;
 480   }
 481
 482   for (i = 0; i < MAX_CERT_TYPE; i++) {
 483     if (sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC)) {
 484       _LOGE("bind error: %s", sqlite3_errmsg(db));
 485       sqlite3_finalize(stmt);
 486       return PMINFO_R_ERROR;
 487     }
 488   }
 489
 490   ret = sqlite3_step(stmt);
 491   sqlite3_finalize(stmt);
 492   if (ret == SQLITE_CONSTRAINT) {
 493     ret =
 494         sqlite3_prepare_v2(db, query_update, strlen(query_update), &stmt, NULL);
 495     if (ret != SQLITE_OK) {
 496       _LOGE("prepare error: %s", sqlite3_errmsg(db));
 497       return PMINFO_R_ERROR;
 498     }
 499
 500     if (sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC)) {
 501       _LOGE("bind error: %s", sqlite3_errmsg(db));
 502       sqlite3_finalize(stmt);
 503       return PMINFO_R_ERROR;
 504     }
 505
 506     ret = sqlite3_step(stmt);
 507     sqlite3_finalize(stmt);
 508   }
 509
 510   if (ret != SQLITE_DONE) {
 511     _LOGE("step error: %s", sqlite3_errmsg(db));
 512     return PMINFO_R_ERROR;
 513   }
 514
 515   return PMINFO_R_OK;
 516 }
 517
 518 static int _pkginfo_save_cert_index_info(sqlite3 *db, char *cert_info[]) {
 519   static const char query[] =
 520       "INSERT OR REPLACE INTO package_cert_index_info "
 521       "(cert_info, cert_id, cert_ref_count) "
 522       "VALUES ( "
 523       " ?, "
 524       " (SELECT cert_id FROM package_cert_index_info "
 525       "  WHERE cert_info=?), "
 526       " COALESCE( "
 527       "  ((SELECT cert_ref_count FROM package_cert_index_info "
 528       "    WHERE cert_info=?) + 1), 1))";
 529   int ret;
 530   sqlite3_stmt *stmt;
 531   int i;
 532   int idx;
 533
 534   ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 535   if (ret != SQLITE_OK) {
 536     _LOGE("prepare error: %s", sqlite3_errmsg(db));
 537     return PMINFO_R_ERROR;
 538   }
 539
 540   for (i = 0; i < MAX_CERT_TYPE; i++) {
 541     if (cert_info[i] == NULL) continue;
 542     idx = 1;
 543     ret = sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC);
 544     if (ret != SQLITE_OK) {
 545       _LOGE("bind failed: %s", sqlite3_errmsg(db));
 546       sqlite3_finalize(stmt);
 547       return PMINFO_R_ERROR;
 548     }
 549     ret = sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC);
 550     if (ret != SQLITE_OK) {
 551       _LOGE("bind failed: %s", sqlite3_errmsg(db));
 552       sqlite3_finalize(stmt);
 553       return PMINFO_R_ERROR;
 554     }
 555     ret = sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC);
 556     if (ret != SQLITE_OK) {
 557       _LOGE("bind failed: %s", sqlite3_errmsg(db));
 558       sqlite3_finalize(stmt);
 559       return PMINFO_R_ERROR;
 560     }
 561
 562     ret = sqlite3_step(stmt);
 563     if (ret != SQLITE_DONE) {
 564       _LOGE("step failed: %s", sqlite3_errmsg(db));
 565       sqlite3_finalize(stmt);
 566       return PMINFO_R_ERROR;
 567     }
 568
 569     sqlite3_reset(stmt);
 570     sqlite3_clear_bindings(stmt);
 571   }
 572
 573   sqlite3_finalize(stmt);
 574
 575   return PMINFO_R_OK;
 576 }
 577
 578 API int pkgmgrinfo_save_certinfo(const char *pkgid,
 579                                  pkgmgrinfo_instcertinfo_h handle, uid_t uid) {
 580   int ret;
 581   sqlite3 *db;
 582   char *dbpath;
 583   pkgmgr_certinfo_x *info = (pkgmgr_certinfo_x *)handle;
 584
 585   if (pkgid == NULL || handle == NULL) {
 586     _LOGE("invalid parameter");
 587     return PMINFO_R_EINVAL;
 588   }
 589
 590   _check_create_cert_db();
 591
 592   /* open unified global cert db */
 593   dbpath = getUserPkgCertDBPath();
 594   if (dbpath == NULL) return PMINFO_R_ERROR;
 595
 596   ret = __open_db(dbpath, &db, SQLITE_OPEN_READWRITE);
 597   if (ret != SQLITE_OK) {
 598     _LOGE("failed to open db: %d", ret);
 599     free(dbpath);
 600     return PMINFO_R_ERROR;
 601   }
 602   free(dbpath);
 603
 604   ret = sqlite3_exec(db, "BEGIN DEFERRED", NULL, NULL, NULL);
 605   if (ret != SQLITE_OK) {
 606     _LOGE("failed to begin transaction");
 607     sqlite3_close_v2(db);
 608     return PMINFO_R_ERROR;
 609   }
 610
 611   if (_pkginfo_save_cert_index_info(db, info->cert_info)) {
 612     _LOGE("failed to save cert index info, rollback now");
 613     ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
 614     if (ret != SQLITE_OK)
 615       LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db));
 616     sqlite3_close_v2(db);
 617     return PMINFO_R_ERROR;
 618   }
 619
 620   if (_pkginfo_save_cert_info(db, pkgid, info->cert_info)) {
 621     _LOGE("failed to save cert info, rollback now");
 622     ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
 623     if (ret != SQLITE_OK)
 624       LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db));
 625     sqlite3_close_v2(db);
 626     return PMINFO_R_ERROR;
 627   }
 628
 629   ret = sqlite3_exec(db, "COMMIT", NULL, NULL, NULL);
 630   if (ret != SQLITE_OK) {
 631     _LOGE("failed to commit transaction, rollback now");
 632     ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
 633     if (ret != SQLITE_OK)
 634       LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db));
 635     sqlite3_close_v2(db);
 636     return PMINFO_R_ERROR;
 637   }
 638
 639   sqlite3_close_v2(db);
 640
 641   return PMINFO_R_OK;
 642 }
 643
 644 API int pkgmgrinfo_destroy_certinfo_set_handle(
 645     pkgmgrinfo_instcertinfo_h handle) {
 646   retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
 647   int i = 0;
 648   pkgmgr_certinfo_x *certinfo = NULL;
 649   certinfo = (pkgmgr_certinfo_x *)handle;
 650   if (certinfo->pkgid) {
 651     free(certinfo->pkgid);
 652     certinfo->pkgid = NULL;
 653   }
 654   for (i = 0; i < MAX_CERT_TYPE; i++) {
 655     if ((certinfo->cert_info)[i]) {
 656       free((certinfo->cert_info)[i]);
 657       (certinfo->cert_info)[i] = NULL;
 658     }
 659   }
 660   free(certinfo);
 661   certinfo = NULL;
 662   return PMINFO_R_OK;
 663 }
 664
 665 static int _pkginfo_delete_certinfo(sqlite3 *db, const char *pkgid) {
 666   static const char query[] =
 667       "UPDATE package_cert_info "
 668       "SET package_count = package_count - 1 "
 669       "WHERE package=?";
 670   int ret;
 671   sqlite3_stmt *stmt;
 672
 673   ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 674   if (ret != SQLITE_OK) {
 675     _LOGE("prepare error: %s", sqlite3_errmsg(db));
 676     return PMINFO_R_ERROR;
 677   }
 678
 679   ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC);
 680   if (ret != SQLITE_OK) {
 681     _LOGE("bind error: %s", sqlite3_errmsg(db));
 682     sqlite3_finalize(stmt);
 683     return PMINFO_R_ERROR;
 684   }
 685
 686   ret = sqlite3_step(stmt);
 687   sqlite3_finalize(stmt);
 688   if (ret != SQLITE_DONE) {
 689     _LOGE("step error: %s", sqlite3_errmsg(db));
 690     return PMINFO_R_ERROR;
 691   }
 692
 693   return PMINFO_R_OK;
 694 }
 695
 696 API int pkgmgrinfo_delete_usr_certinfo(const char *pkgid, uid_t uid) {
 697   int ret;
 698   sqlite3 *db;
 699   char *dbpath;
 700
 701   if (pkgid == NULL) {
 702     _LOGE("invalid parameter");
 703     return PMINFO_R_EINVAL;
 704   }
 705
 706   /* open unified global cert db */
 707   dbpath = getUserPkgCertDBPath();
 708   if (dbpath == NULL) return PMINFO_R_ERROR;
 709
 710   ret = __open_db(dbpath, &db, SQLITE_OPEN_READWRITE);
 711   if (ret != SQLITE_OK) {
 712     _LOGE("failed to open db: %d", ret);
 713     free(dbpath);
 714     return PMINFO_R_ERROR;
 715   }
 716   free(dbpath);
 717
 718   ret = sqlite3_exec(db, "BEGIN DEFERRED", NULL, NULL, NULL);
 719   if (ret != SQLITE_OK) {
 720     _LOGE("failed to begin transaction");
 721     sqlite3_close_v2(db);
 722     return PMINFO_R_ERROR;
 723   }
 724
 725   if (_pkginfo_delete_certinfo(db, pkgid)) {
 726     _LOGE("failed to delete certinfo of %s, rollback now", pkgid);
 727     ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
 728     if (ret != SQLITE_OK)
 729       LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db));
 730     sqlite3_close_v2(db);
 731     return PMINFO_R_ERROR;
 732   }
 733
 734   ret = sqlite3_exec(db, "COMMIT", NULL, NULL, NULL);
 735   if (ret != SQLITE_OK) {
 736     _LOGE("failed to commit transaction, rollback now");
 737     ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
 738     if (ret != SQLITE_OK)
 739       LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db));
 740     sqlite3_close_v2(db);
 741     return PMINFO_R_ERROR;
 742   }
 743
 744   sqlite3_close_v2(db);
 745
 746   return PMINFO_R_OK;
 747 }
 748
 749 API int pkgmgrinfo_delete_certinfo(const char *pkgid) {
 750   return pkgmgrinfo_delete_usr_certinfo(pkgid, _getuid());
 751 }