13 #include "pkgmgr-info.h"
14 #include "pkgmgrinfo_debug.h"
15 #include "pkgmgrinfo_private.h"
16 #include "pkgmgr_parser.h"
18 typedef struct _pkgmgr_certinfo_x {
22 char *cert_info[MAX_CERT_TYPE]; /*certificate info*/
23 int cert_id[MAX_CERT_TYPE]; /*certificate ID in index table*/
26 typedef struct _pkgmgr_instcertinfo_x {
28 char *cert_info[MAX_CERT_TYPE]; /*certificate data*/
29 int is_new[MAX_CERT_TYPE]; /*whether already exist in table or not*/
30 int ref_count[MAX_CERT_TYPE]; /*reference count of certificate data*/
31 int cert_id[MAX_CERT_TYPE]; /*certificate ID in index table*/
32 } pkgmgr_instcertinfo_x;
34 typedef struct _pkgmgr_certindexinfo_x {
37 } pkgmgr_certindexinfo_x;
39 typedef struct _pkgmgr_cert_x {
44 API int pkgmgrinfo_pkginfo_create_certinfo(pkgmgrinfo_certinfo_h *handle)
46 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
47 pkgmgr_certinfo_x *certinfo = NULL;
48 certinfo = calloc(1, sizeof(pkgmgr_certinfo_x));
50 retvm_if(certinfo == NULL, PMINFO_R_ERROR, "Malloc Failed\n");
51 *handle = (void *)certinfo;
55 static int _pkginfo_compare_certinfo(sqlite3 *db, const char *l_pkgid,
57 pkgmgrinfo_cert_compare_result_type_e *result)
59 static const char query[] =
60 "SELECT author_signer_cert FROM package_cert_info "
65 int certid[2] = {-1, };
68 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
69 if (ret != SQLITE_OK) {
70 _LOGE("prepare error: %s", sqlite3_errmsg(db));
71 return PMINFO_R_ERROR;
76 for (i = 0; i < 2; i++) {
77 ret = sqlite3_bind_text(stmt, 1, pkgid[i], -1, SQLITE_STATIC);
78 if (ret != SQLITE_OK) {
79 _LOGE("bind error: %s", sqlite3_errmsg(db));
80 sqlite3_finalize(stmt);
81 return PMINFO_R_ERROR;
84 ret = sqlite3_step(stmt);
85 if (ret == SQLITE_ROW) {
86 _save_column_int(stmt, 0, &certid[i]);
87 } else if (ret != SQLITE_DONE) {
88 _LOGE("step error: %s", sqlite3_errmsg(db));
89 sqlite3_finalize(stmt);
90 return PMINFO_R_ERROR;
94 sqlite3_clear_bindings(stmt);
97 if (certid[0] == -1 && certid[1] == -1)
98 *result = PMINFO_CERT_COMPARE_BOTH_NO_CERT;
99 else if (certid[0] == -1)
100 *result = PMINFO_CERT_COMPARE_LHS_NO_CERT;
101 else if (certid[1] == -1)
102 *result = PMINFO_CERT_COMPARE_RHS_NO_CERT;
103 else if (certid[0] == certid[1])
104 *result = PMINFO_CERT_COMPARE_MATCH;
106 *result = PMINFO_CERT_COMPARE_MISMATCH;
108 sqlite3_finalize(stmt);
113 API int pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(const char *lhs_package_id,
114 const char *rhs_package_id, uid_t uid,
115 pkgmgrinfo_cert_compare_result_type_e *compare_result)
121 if (lhs_package_id == NULL || rhs_package_id == NULL ||
122 compare_result == NULL) {
123 _LOGE("invalid parameter");
124 return PMINFO_R_EINVAL;
127 /* open unified global cert db */
128 dbpath = getUserPkgCertDBPathUID(GLOBAL_USER);
130 return PMINFO_R_ERROR;
132 ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
133 if (ret != SQLITE_OK) {
134 _LOGE("failed to open db: %d", ret);
135 return PMINFO_R_ERROR;
138 if (_pkginfo_compare_certinfo(db, lhs_package_id, rhs_package_id,
140 _LOGE("failed to compare certinfo");
141 sqlite3_close_v2(db);
142 return PMINFO_R_ERROR;
145 sqlite3_close_v2(db);
150 API int pkgmgrinfo_pkginfo_compare_pkg_cert_info(const char *lhs_package_id, const char *rhs_package_id, pkgmgrinfo_cert_compare_result_type_e *compare_result)
152 return pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(lhs_package_id, rhs_package_id, GLOBAL_USER, compare_result);
155 static int _pkginfo_get_pkgid_from_appid(uid_t uid, const char *appid,
158 static const char query[] =
159 "SELECT package FROM package_app_info WHERE app_id=?";
165 dbpath = getUserPkgParserDBPathUID(uid);
167 return PMINFO_R_ERROR;
169 ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
170 if (ret != SQLITE_OK) {
171 _LOGE("failed to open db: %d", ret);
172 return PMINFO_R_ERROR;
175 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
176 if (ret != SQLITE_OK) {
177 _LOGE("prepare error: %s", sqlite3_errmsg(db));
178 sqlite3_close_v2(db);
179 return PMINFO_R_ERROR;
182 ret = sqlite3_bind_text(stmt, 1, appid, -1, SQLITE_STATIC);
183 if (ret != SQLITE_OK) {
184 _LOGE("bind error: %s", sqlite3_errmsg(db));
185 sqlite3_finalize(stmt);
186 sqlite3_close_v2(db);
187 return PMINFO_R_ERROR;
190 ret = sqlite3_step(stmt);
191 if (ret == SQLITE_ROW) {
192 _save_column_str(stmt, 0, (const char **)pkgid);
194 } else if (ret == SQLITE_DONE) {
195 _LOGE("cannot find pkgid of app %s", appid);
196 ret = PMINFO_R_ENOENT;
198 _LOGE("step error: %s", sqlite3_errmsg(db));
199 ret = PMINFO_R_ERROR;
202 sqlite3_finalize(stmt);
203 sqlite3_close_v2(db);
208 API int pkgmgrinfo_pkginfo_compare_usr_app_cert_info(const char *lhs_app_id,
209 const char *rhs_app_id, uid_t uid,
210 pkgmgrinfo_cert_compare_result_type_e *compare_result)
213 char *l_pkgid = NULL;
214 char *r_pkgid = NULL;
216 if (lhs_app_id == NULL || rhs_app_id == NULL ||
217 compare_result == NULL) {
218 _LOGE("invalid parameter");
219 return PMINFO_R_EINVAL;
222 ret = _pkginfo_get_pkgid_from_appid(uid, lhs_app_id, &l_pkgid);
223 if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
224 ret = _pkginfo_get_pkgid_from_appid(GLOBAL_USER, lhs_app_id,
227 if (ret != PMINFO_R_OK)
230 ret = _pkginfo_get_pkgid_from_appid(uid, rhs_app_id, &r_pkgid);
231 if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
232 ret = _pkginfo_get_pkgid_from_appid(GLOBAL_USER, rhs_app_id,
235 if (ret != PMINFO_R_OK) {
240 ret = pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(l_pkgid, r_pkgid,
241 uid, compare_result);
249 API int pkgmgrinfo_pkginfo_compare_app_cert_info(const char *lhs_app_id,
250 const char *rhs_app_id,
251 pkgmgrinfo_cert_compare_result_type_e *compare_result)
253 return pkgmgrinfo_pkginfo_compare_usr_app_cert_info(lhs_app_id,
254 rhs_app_id, GLOBAL_USER, compare_result);
257 static int _pkginfo_get_cert(sqlite3 *db, int cert_id[],
260 static const char query[] =
261 "SELECT cert_info FROM package_cert_index_info WHERE cert_id=?";
266 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
267 if (ret != SQLITE_OK) {
268 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
269 return PMINFO_R_ERROR;
272 for (i = 0; i < MAX_CERT_TYPE; i++) {
273 ret = sqlite3_bind_int(stmt, 1, cert_id[i]);
274 if (ret != SQLITE_OK) {
275 sqlite3_finalize(stmt);
276 _LOGE("bind failed: %s", sqlite3_errmsg(db));
277 return PMINFO_R_ERROR;
280 ret = sqlite3_step(stmt);
281 if (ret == SQLITE_DONE) {
283 sqlite3_clear_bindings(stmt);
285 } else if (ret != SQLITE_ROW) {
286 _LOGE("step failed: %s", sqlite3_errmsg(db));
287 sqlite3_finalize(stmt);
288 return PMINFO_R_ERROR;
291 _save_column_str(stmt, 0, (const char **)&cert_info[i]);
293 sqlite3_clear_bindings(stmt);
296 sqlite3_finalize(stmt);
301 static int _pkginfo_get_certid(sqlite3 *db, const char *pkgid, int cert_id[])
303 static const char query[] =
304 "SELECT author_root_cert, author_im_cert, author_signer_cert, "
305 "dist_root_cert, dist_im_cert, dist_signer_cert, "
306 "dist2_root_cert, dist2_im_cert, dist2_signer_cert "
307 "FROM package_cert_info WHERE package=?";
312 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
313 if (ret != SQLITE_OK) {
314 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
315 return PMINFO_R_ERROR;
318 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC);
319 if (ret != SQLITE_OK) {
320 _LOGE("bind failed: %s", sqlite3_errmsg(db));
321 sqlite3_finalize(stmt);
322 return PMINFO_R_ERROR;
325 ret = sqlite3_step(stmt);
326 if (ret == SQLITE_DONE) {
327 sqlite3_finalize(stmt);
328 return PMINFO_R_ENOENT;
329 } else if (ret != SQLITE_ROW) {
330 _LOGE("step failed: %s", sqlite3_errmsg(db));
331 sqlite3_finalize(stmt);
332 return PMINFO_R_ERROR;
336 _save_column_int(stmt, idx++, &cert_id[PMINFO_AUTHOR_ROOT_CERT]);
337 _save_column_int(stmt, idx++,
338 &cert_id[PMINFO_AUTHOR_INTERMEDIATE_CERT]);
339 _save_column_int(stmt, idx++, &cert_id[PMINFO_AUTHOR_SIGNER_CERT]);
340 _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR_ROOT_CERT]);
341 _save_column_int(stmt, idx++,
342 &cert_id[PMINFO_DISTRIBUTOR_INTERMEDIATE_CERT]);
343 _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR_SIGNER_CERT]);
344 _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR2_ROOT_CERT]);
345 _save_column_int(stmt, idx++,
346 &cert_id[PMINFO_DISTRIBUTOR2_INTERMEDIATE_CERT]);
347 _save_column_int(stmt, idx++,
348 &cert_id[PMINFO_DISTRIBUTOR2_SIGNER_CERT]);
350 sqlite3_finalize(stmt);
355 static int _pkginfo_get_certinfo(const char *pkgid, pkgmgr_certinfo_x *info)
361 /* open unified global cert db */
362 dbpath = getUserPkgCertDBPathUID(GLOBAL_USER);
364 return PMINFO_R_ERROR;
366 ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL);
367 if (ret != SQLITE_OK) {
368 _LOGE("failed to open db: %d", ret);
369 return PMINFO_R_ERROR;
372 ret = _pkginfo_get_certid(db, pkgid, info->cert_id);
373 if (ret != PMINFO_R_OK) {
374 sqlite3_close_v2(db);
378 ret = _pkginfo_get_cert(db, info->cert_id, info->cert_info);
379 if (ret != PMINFO_R_OK) {
380 sqlite3_close_v2(db);
387 API int pkgmgrinfo_pkginfo_load_certinfo(const char *pkgid, pkgmgrinfo_certinfo_h handle, uid_t uid)
390 pkgmgr_certinfo_x *info = (pkgmgr_certinfo_x *)handle;
392 if (pkgid == NULL || handle == NULL) {
393 _LOGE("invalid parameter");
394 return PMINFO_R_EINVAL;
397 ret = _pkginfo_get_certinfo(pkgid, info);
398 if (ret != PMINFO_R_OK)
399 _LOGE("failed to get certinfo of %s ", pkgid);
404 API int pkgmgrinfo_pkginfo_get_cert_value(pkgmgrinfo_certinfo_h handle, pkgmgrinfo_cert_type cert_type, const char **cert_value)
406 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
407 retvm_if(cert_value == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
408 retvm_if(cert_type < PMINFO_AUTHOR_ROOT_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
409 retvm_if(cert_type > PMINFO_DISTRIBUTOR2_SIGNER_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
410 pkgmgr_certinfo_x *certinfo = NULL;
411 certinfo = (pkgmgr_certinfo_x *)handle;
412 if ((certinfo->cert_info)[cert_type])
413 *cert_value = (certinfo->cert_info)[cert_type];
419 API int pkgmgrinfo_pkginfo_destroy_certinfo(pkgmgrinfo_certinfo_h handle)
421 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
423 pkgmgr_certinfo_x *certinfo = NULL;
424 certinfo = (pkgmgr_certinfo_x *)handle;
425 if (certinfo->pkgid) {
426 free(certinfo->pkgid);
427 certinfo->pkgid = NULL;
429 for (i = 0; i < MAX_CERT_TYPE; i++) {
430 if ((certinfo->cert_info)[i]) {
431 free((certinfo->cert_info)[i]);
432 (certinfo->cert_info)[i] = NULL;
440 API int pkgmgrinfo_create_certinfo_set_handle(pkgmgrinfo_instcertinfo_h *handle)
442 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
443 pkgmgr_instcertinfo_x *certinfo = NULL;
445 certinfo = calloc(1, sizeof(pkgmgr_instcertinfo_x));
446 retvm_if(certinfo == NULL, PMINFO_R_ERROR, "Malloc Failed\n");
447 *handle = (void *)certinfo;
451 API int pkgmgrinfo_set_cert_value(pkgmgrinfo_instcertinfo_h handle, pkgmgrinfo_instcert_type cert_type, char *cert_value)
453 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
454 retvm_if(cert_value == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
455 retvm_if(cert_type < PMINFO_SET_AUTHOR_ROOT_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
456 retvm_if(cert_type > PMINFO_SET_DISTRIBUTOR2_SIGNER_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
457 pkgmgr_instcertinfo_x *certinfo = NULL;
458 certinfo = (pkgmgr_instcertinfo_x *)handle;
459 (certinfo->cert_info)[cert_type] = strdup(cert_value);
463 static int _pkginfo_save_cert_info(sqlite3 *db, const char *pkgid,
466 static const char query[] =
467 "INSERT OR REPLACE INTO package_cert_info (package,"
468 " author_root_cert, author_im_cert, author_signer_cert,"
469 " dist_root_cert, dist_im_cert, dist_signer_cert,"
470 " dist2_root_cert, dist2_im_cert, dist2_signer_cert) "
473 " (SELECT cert_id FROM package_cert_index_info"
474 " WHERE cert_info=?),"
475 " (SELECT author_root_cert FROM package_cert_info"
476 " WHERE package=?))),"
478 " (SELECT cert_id FROM package_cert_index_info"
479 " WHERE cert_info=?),"
480 " (SELECT author_im_cert FROM package_cert_info"
481 " WHERE package=?))),"
483 " (SELECT cert_id FROM package_cert_index_info"
484 " WHERE cert_info=?),"
485 " (SELECT author_signer_cert FROM package_cert_info"
486 " WHERE package=?))),"
488 " (SELECT cert_id FROM package_cert_index_info"
489 " WHERE cert_info=?),"
490 " (SELECT dist_root_cert FROM package_cert_info"
491 " WHERE package=?))),"
493 " (SELECT cert_id FROM package_cert_index_info"
494 " WHERE cert_info=?),"
495 " (SELECT dist_im_cert FROM package_cert_info"
496 " WHERE package=?))),"
498 " (SELECT cert_id FROM package_cert_index_info"
499 " WHERE cert_info=?),"
500 " (SELECT dist_signer_cert FROM package_cert_info"
501 " WHERE package=?))),"
503 " (SELECT cert_id FROM package_cert_index_info"
504 " WHERE cert_info=?),"
505 " (SELECT dist2_root_cert FROM package_cert_info"
506 " WHERE package=?))),"
508 " (SELECT cert_id FROM package_cert_index_info"
509 " WHERE cert_info=?),"
510 " (SELECT dist2_im_cert FROM package_cert_info"
511 " WHERE package=?))),"
513 " (SELECT cert_id FROM package_cert_index_info"
514 " WHERE cert_info=?),"
515 " (SELECT dist2_signer_cert FROM package_cert_info"
516 " WHERE package=?))))";
522 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
523 if (ret != SQLITE_OK) {
524 _LOGE("prepare error: %s", sqlite3_errmsg(db));
525 return PMINFO_R_ERROR;
529 sqlite3_bind_text(stmt, idx++, pkgid, -1, SQLITE_STATIC);
530 for (i = 0; i < MAX_CERT_TYPE; i++) {
531 ret = sqlite3_bind_text(stmt, idx++, cert_info[i], -1,
533 if (ret != SQLITE_OK) {
534 _LOGE("bind error: %s", sqlite3_errmsg(db));
535 sqlite3_finalize(stmt);
536 return PMINFO_R_ERROR;
538 ret = sqlite3_bind_text(stmt, idx++, pkgid, -1,
540 if (ret != SQLITE_OK) {
541 _LOGE("bind error: %s", sqlite3_errmsg(db));
542 sqlite3_finalize(stmt);
543 return PMINFO_R_ERROR;
546 ret = sqlite3_step(stmt);
547 sqlite3_finalize(stmt);
548 if (ret != SQLITE_DONE) {
549 _LOGE("step error: %s", sqlite3_errmsg(db));
550 return PMINFO_R_ERROR;
556 static int _pkginfo_save_cert_index_info(sqlite3 *db, char *cert_info[])
558 static const char query[] =
559 "INSERT OR REPLACE INTO package_cert_index_info "
560 "(cert_info, cert_id, cert_ref_count) "
563 " (SELECT cert_id FROM package_cert_index_info "
564 " WHERE cert_info=?), "
566 " ((SELECT cert_ref_count FROM package_cert_index_info "
567 " WHERE cert_info=?) + 1), 1))";
573 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
574 if (ret != SQLITE_OK) {
575 _LOGE("prepare error: %s", sqlite3_errmsg(db));
576 return PMINFO_R_ERROR;
579 for (i = 0; i < MAX_CERT_TYPE; i++) {
580 if (cert_info[i] == NULL)
583 sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC);
584 sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC);
585 sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC);
587 ret = sqlite3_step(stmt);
588 if (ret != SQLITE_DONE) {
589 _LOGE("step failed: %s", sqlite3_errmsg(db));
590 sqlite3_finalize(stmt);
591 return PMINFO_R_ERROR;
595 sqlite3_clear_bindings(stmt);
598 sqlite3_finalize(stmt);
603 API int pkgmgrinfo_save_certinfo(const char *pkgid, pkgmgrinfo_instcertinfo_h handle, uid_t uid)
608 pkgmgr_instcertinfo_x *info = (pkgmgr_instcertinfo_x *)handle;
610 if (pkgid == NULL || handle == NULL) {
611 _LOGE("invalid parameter");
612 return PMINFO_R_EINVAL;
615 /* open unified global cert db */
616 dbpath = getUserPkgCertDBPathUID(GLOBAL_USER);
618 return PMINFO_R_ERROR;
620 ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READWRITE, NULL);
621 if (ret != SQLITE_OK) {
622 _LOGE("failed to open db: %d", ret);
623 return PMINFO_R_ERROR;
626 ret = sqlite3_exec(db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
627 if (ret != SQLITE_OK) {
628 _LOGE("failed to begin transaction");
629 sqlite3_close_v2(db);
630 return PMINFO_R_ERROR;
633 _check_create_cert_db(db);
635 if (_pkginfo_save_cert_index_info(db, info->cert_info)) {
636 _LOGE("failed to save cert index info, rollback now");
637 sqlite3_exec(GET_DB(cert_db), "ROLLBACK", NULL, NULL, NULL);
638 sqlite3_close_v2(db);
639 return PMINFO_R_ERROR;
641 if (_pkginfo_save_cert_info(db, pkgid, info->cert_info)) {
642 _LOGE("failed to save cert info, rollback now");
643 sqlite3_exec(GET_DB(cert_db), "ROLLBACK", NULL, NULL, NULL);
644 sqlite3_close_v2(db);
645 return PMINFO_R_ERROR;
648 ret = sqlite3_exec(db, "COMMIT", NULL, NULL, NULL);
649 if (ret != SQLITE_OK) {
650 _LOGE("failed to commit transaction, rollback now");
651 sqlite3_exec(GET_DB(cert_db), "ROLLBACK", NULL, NULL, NULL);
652 sqlite3_close_v2(db);
653 return PMINFO_R_ERROR;
656 sqlite3_close_v2(db);
661 API int pkgmgrinfo_destroy_certinfo_set_handle(pkgmgrinfo_instcertinfo_h handle)
663 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
665 pkgmgr_instcertinfo_x *certinfo = NULL;
666 certinfo = (pkgmgr_instcertinfo_x *)handle;
667 if (certinfo->pkgid) {
668 free(certinfo->pkgid);
669 certinfo->pkgid = NULL;
671 for (i = 0; i < MAX_CERT_TYPE; i++) {
672 if ((certinfo->cert_info)[i]) {
673 free((certinfo->cert_info)[i]);
674 (certinfo->cert_info)[i] = NULL;
682 static int _pkginfo_delete_certinfo(sqlite3 *db, const char *pkgid)
684 static const char query[] =
685 "DELETE FROM package_cert_info WHERE package=?";
689 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
690 if (ret != SQLITE_OK) {
691 _LOGE("prepare error: %s", sqlite3_errmsg(db));
692 return PMINFO_R_ERROR;
695 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC);
696 if (ret != SQLITE_OK) {
697 _LOGE("bind error: %s", sqlite3_errmsg(db));
698 sqlite3_finalize(stmt);
699 return PMINFO_R_ERROR;
702 ret = sqlite3_step(stmt);
703 sqlite3_finalize(stmt);
704 if (ret != SQLITE_DONE) {
705 _LOGE("step error: %s", sqlite3_errmsg(db));
706 return PMINFO_R_ERROR;
712 API int pkgmgrinfo_delete_usr_certinfo(const char *pkgid, uid_t uid)
719 _LOGE("invalid parameter");
720 return PMINFO_R_EINVAL;
723 /* open unified global cert db */
724 dbpath = getUserPkgCertDBPathUID(GLOBAL_USER);
726 return PMINFO_R_ERROR;
728 ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READWRITE, NULL);
729 if (ret != SQLITE_OK) {
730 _LOGE("failed to open db: %d", ret);
731 return PMINFO_R_ERROR;
734 ret = sqlite3_exec(db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
735 if (ret != SQLITE_OK) {
736 _LOGE("failed to begin transaction");
737 sqlite3_close_v2(db);
738 return PMINFO_R_ERROR;
741 if (_pkginfo_delete_certinfo(db, pkgid)) {
742 _LOGE("failed to delete certinfo of %s, rollback now", pkgid);
743 sqlite3_exec(GET_DB(cert_db), "ROLLBACK", NULL, NULL, NULL);
744 sqlite3_close_v2(db);
745 return PMINFO_R_ERROR;
748 ret = sqlite3_exec(db, "COMMIT", NULL, NULL, NULL);
749 if (ret != SQLITE_OK) {
750 _LOGE("failed to commit transaction, rollback now");
751 sqlite3_exec(GET_DB(cert_db), "ROLLBACK", NULL, NULL, NULL);
752 sqlite3_close_v2(db);
753 return PMINFO_R_ERROR;
756 sqlite3_close_v2(db);
761 API int pkgmgrinfo_delete_certinfo(const char *pkgid)
763 return pkgmgrinfo_delete_usr_certinfo(pkgid, GLOBAL_USER);