11 #include "pkgmgr-info.h"
12 #include "pkgmgrinfo_debug.h"
13 #include "pkgmgrinfo_private.h"
14 #include "pkgmgr_parser.h"
16 API int pkgmgrinfo_pkginfo_create_certinfo(pkgmgrinfo_certinfo_h *handle)
18 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
19 pkgmgr_certinfo_x *certinfo = NULL;
20 certinfo = calloc(1, sizeof(pkgmgr_certinfo_x));
22 retvm_if(certinfo == NULL, PMINFO_R_ERROR, "Malloc Failed\n");
23 *handle = (void *)certinfo;
27 static int _pkginfo_compare_certinfo(sqlite3 *db, const char *l_pkgid,
29 pkgmgrinfo_cert_compare_result_type_e *result)
31 static const char query[] =
32 "SELECT COALESCE(author_signer_cert, -1) FROM package_cert_info "
37 int certid[2] = {-1, -1};
43 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
44 if (ret != SQLITE_OK) {
45 _LOGE("prepare error: %s", sqlite3_errmsg(db));
46 return PMINFO_R_ERROR;
49 for (i = 0; i < 2; i++) {
50 ret = sqlite3_bind_text(stmt, 1, pkgid[i], -1, SQLITE_STATIC);
51 if (ret != SQLITE_OK) {
52 _LOGE("bind error: %s", sqlite3_errmsg(db));
53 sqlite3_finalize(stmt);
54 return PMINFO_R_ERROR;
57 ret = sqlite3_step(stmt);
58 if (ret == SQLITE_ROW) {
59 _save_column_int(stmt, 0, &certid[i]);
60 } else if (ret != SQLITE_DONE) {
61 _LOGE("step error: %s", sqlite3_errmsg(db));
62 sqlite3_finalize(stmt);
63 return PMINFO_R_ERROR;
67 sqlite3_clear_bindings(stmt);
70 if (certid[0] == -1 && certid[1] == -1)
71 *result = PMINFO_CERT_COMPARE_BOTH_NO_CERT;
72 else if (certid[0] == -1)
73 *result = PMINFO_CERT_COMPARE_LHS_NO_CERT;
74 else if (certid[1] == -1)
75 *result = PMINFO_CERT_COMPARE_RHS_NO_CERT;
76 else if (certid[0] == certid[1])
77 *result = PMINFO_CERT_COMPARE_MATCH;
79 *result = PMINFO_CERT_COMPARE_MISMATCH;
81 sqlite3_finalize(stmt);
85 API int pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(const char *lhs_package_id,
86 const char *rhs_package_id, uid_t uid,
87 pkgmgrinfo_cert_compare_result_type_e *compare_result)
93 if (lhs_package_id == NULL || rhs_package_id == NULL ||
94 compare_result == NULL) {
95 _LOGE("invalid parameter");
96 return PMINFO_R_EINVAL;
99 /* open unified global cert db */
100 dbpath = getUserPkgCertDBPath();
102 return PMINFO_R_ERROR;
104 ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY);
105 if (ret != SQLITE_OK) {
106 _LOGE("failed to open db: %d", ret);
108 return PMINFO_R_ERROR;
112 if (_pkginfo_compare_certinfo(db, lhs_package_id, rhs_package_id,
114 _LOGE("failed to compare certinfo");
115 sqlite3_close_v2(db);
116 return PMINFO_R_ERROR;
119 sqlite3_close_v2(db);
124 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)
126 return pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(lhs_package_id, rhs_package_id, _getuid(), compare_result);
129 static int _pkginfo_get_pkgid_from_appid(uid_t uid, const char *appid,
132 static const char query[] =
133 "SELECT package FROM package_app_info WHERE app_id=?";
139 dbpath = getUserPkgParserDBPathUID(uid);
141 return PMINFO_R_ERROR;
143 ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY);
144 if (ret != SQLITE_OK) {
145 _LOGE("failed to open db: %d", ret);
147 return PMINFO_R_ERROR;
151 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
152 if (ret != SQLITE_OK) {
153 _LOGE("prepare error: %s", sqlite3_errmsg(db));
154 sqlite3_close_v2(db);
155 return PMINFO_R_ERROR;
158 ret = sqlite3_bind_text(stmt, 1, appid, -1, SQLITE_STATIC);
159 if (ret != SQLITE_OK) {
160 _LOGE("bind error: %s", sqlite3_errmsg(db));
161 sqlite3_finalize(stmt);
162 sqlite3_close_v2(db);
163 return PMINFO_R_ERROR;
166 ret = sqlite3_step(stmt);
167 if (ret == SQLITE_ROW) {
168 _save_column_str(stmt, 0, pkgid);
170 } else if (ret == SQLITE_DONE) {
171 _LOGI("cannot find pkgid of app %s for uid %d", appid, (int)uid);
172 ret = PMINFO_R_ENOENT;
174 _LOGE("step error: %s", sqlite3_errmsg(db));
175 ret = PMINFO_R_ERROR;
178 sqlite3_finalize(stmt);
179 sqlite3_close_v2(db);
184 API int pkgmgrinfo_pkginfo_compare_usr_app_cert_info(const char *lhs_app_id,
185 const char *rhs_app_id, uid_t uid,
186 pkgmgrinfo_cert_compare_result_type_e *compare_result)
189 char *l_pkgid = NULL;
190 char *r_pkgid = NULL;
192 if (lhs_app_id == NULL || rhs_app_id == NULL ||
193 compare_result == NULL) {
194 _LOGE("invalid parameter");
195 return PMINFO_R_EINVAL;
198 ret = _pkginfo_get_pkgid_from_appid(uid, lhs_app_id, &l_pkgid);
199 if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
200 ret = _pkginfo_get_pkgid_from_appid(GLOBAL_USER, lhs_app_id,
203 if (ret != PMINFO_R_OK)
206 ret = _pkginfo_get_pkgid_from_appid(uid, rhs_app_id, &r_pkgid);
207 if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
208 ret = _pkginfo_get_pkgid_from_appid(GLOBAL_USER, rhs_app_id,
211 if (ret != PMINFO_R_OK) {
216 ret = pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(l_pkgid, r_pkgid,
217 uid, compare_result);
225 API int pkgmgrinfo_pkginfo_compare_app_cert_info(const char *lhs_app_id,
226 const char *rhs_app_id,
227 pkgmgrinfo_cert_compare_result_type_e *compare_result)
229 return pkgmgrinfo_pkginfo_compare_usr_app_cert_info(lhs_app_id,
230 rhs_app_id, _getuid(), compare_result);
233 static int _pkginfo_get_cert(sqlite3 *db, int cert_id[],
236 static const char query[] =
237 "SELECT cert_info FROM package_cert_index_info WHERE cert_id=?";
242 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
243 if (ret != SQLITE_OK) {
244 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
245 return PMINFO_R_ERROR;
248 for (i = 0; i < MAX_CERT_TYPE; i++) {
249 ret = sqlite3_bind_int(stmt, 1, cert_id[i]);
250 if (ret != SQLITE_OK) {
251 sqlite3_finalize(stmt);
252 _LOGE("bind failed: %s", sqlite3_errmsg(db));
253 return PMINFO_R_ERROR;
256 ret = sqlite3_step(stmt);
257 if (ret == SQLITE_DONE) {
259 sqlite3_clear_bindings(stmt);
261 } else if (ret != SQLITE_ROW) {
262 _LOGE("step failed: %s", sqlite3_errmsg(db));
263 sqlite3_finalize(stmt);
264 return PMINFO_R_ERROR;
267 _save_column_str(stmt, 0, &cert_info[i]);
269 sqlite3_clear_bindings(stmt);
272 sqlite3_finalize(stmt);
277 static int _pkginfo_get_certid(sqlite3 *db, const char *pkgid, int cert_id[])
279 static const char query[] =
280 "SELECT author_root_cert, author_im_cert, author_signer_cert, "
281 "dist_root_cert, dist_im_cert, dist_signer_cert, "
282 "dist2_root_cert, dist2_im_cert, dist2_signer_cert "
283 "FROM package_cert_info WHERE package=?";
288 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
289 if (ret != SQLITE_OK) {
290 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
291 return PMINFO_R_ERROR;
294 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC);
295 if (ret != SQLITE_OK) {
296 _LOGE("bind failed: %s", sqlite3_errmsg(db));
297 sqlite3_finalize(stmt);
298 return PMINFO_R_ERROR;
301 ret = sqlite3_step(stmt);
302 if (ret == SQLITE_DONE) {
303 sqlite3_finalize(stmt);
304 return PMINFO_R_ENOENT;
305 } else if (ret != SQLITE_ROW) {
306 _LOGE("step failed: %s", sqlite3_errmsg(db));
307 sqlite3_finalize(stmt);
308 return PMINFO_R_ERROR;
312 _save_column_int(stmt, idx++, &cert_id[PMINFO_AUTHOR_ROOT_CERT]);
313 _save_column_int(stmt, idx++,
314 &cert_id[PMINFO_AUTHOR_INTERMEDIATE_CERT]);
315 _save_column_int(stmt, idx++, &cert_id[PMINFO_AUTHOR_SIGNER_CERT]);
316 _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR_ROOT_CERT]);
317 _save_column_int(stmt, idx++,
318 &cert_id[PMINFO_DISTRIBUTOR_INTERMEDIATE_CERT]);
319 _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR_SIGNER_CERT]);
320 _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR2_ROOT_CERT]);
321 _save_column_int(stmt, idx++,
322 &cert_id[PMINFO_DISTRIBUTOR2_INTERMEDIATE_CERT]);
323 _save_column_int(stmt, idx++,
324 &cert_id[PMINFO_DISTRIBUTOR2_SIGNER_CERT]);
326 sqlite3_finalize(stmt);
331 static int _pkginfo_get_certinfo(const char *pkgid, pkgmgr_certinfo_x *info)
337 /* open unified global cert db */
338 dbpath = getUserPkgCertDBPath();
340 return PMINFO_R_ERROR;
342 ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY);
343 if (ret != SQLITE_OK) {
344 _LOGE("failed to open db: %d", ret);
346 return PMINFO_R_ERROR;
350 ret = _pkginfo_get_certid(db, pkgid, info->cert_id);
351 if (ret != PMINFO_R_OK) {
352 sqlite3_close_v2(db);
356 ret = _pkginfo_get_cert(db, info->cert_id, info->cert_info);
357 if (ret != PMINFO_R_OK) {
358 sqlite3_close_v2(db);
362 sqlite3_close_v2(db);
367 API int pkgmgrinfo_pkginfo_load_certinfo(const char *pkgid, pkgmgrinfo_certinfo_h handle, uid_t uid)
370 pkgmgr_certinfo_x *info = (pkgmgr_certinfo_x *)handle;
372 if (pkgid == NULL || handle == NULL) {
373 _LOGE("invalid parameter");
374 return PMINFO_R_EINVAL;
377 ret = _pkginfo_get_certinfo(pkgid, info);
378 if (ret != PMINFO_R_OK)
379 _LOGE("failed to get certinfo of %s ", pkgid);
384 API int pkgmgrinfo_pkginfo_get_cert_value(pkgmgrinfo_certinfo_h handle, pkgmgrinfo_cert_type cert_type, const char **cert_value)
386 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
387 retvm_if(cert_value == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
388 retvm_if(cert_type < PMINFO_AUTHOR_ROOT_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
389 retvm_if(cert_type > PMINFO_DISTRIBUTOR2_SIGNER_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
390 pkgmgr_certinfo_x *certinfo = NULL;
391 certinfo = (pkgmgr_certinfo_x *)handle;
392 if ((certinfo->cert_info)[cert_type])
393 *cert_value = (certinfo->cert_info)[cert_type];
399 API int pkgmgrinfo_pkginfo_destroy_certinfo(pkgmgrinfo_certinfo_h handle)
401 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
403 pkgmgr_certinfo_x *certinfo = NULL;
404 certinfo = (pkgmgr_certinfo_x *)handle;
405 if (certinfo->pkgid) {
406 free(certinfo->pkgid);
407 certinfo->pkgid = NULL;
409 for (i = 0; i < MAX_CERT_TYPE; i++) {
410 if ((certinfo->cert_info)[i]) {
411 free((certinfo->cert_info)[i]);
412 (certinfo->cert_info)[i] = NULL;
420 API int pkgmgrinfo_create_certinfo_set_handle(pkgmgrinfo_instcertinfo_h *handle)
422 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
423 pkgmgr_certinfo_x *certinfo = NULL;
425 certinfo = calloc(1, sizeof(pkgmgr_certinfo_x));
426 retvm_if(certinfo == NULL, PMINFO_R_ERROR, "Malloc Failed\n");
427 *handle = (void *)certinfo;
431 API int pkgmgrinfo_set_cert_value(pkgmgrinfo_instcertinfo_h handle, pkgmgrinfo_instcert_type cert_type, char *cert_value)
433 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
434 retvm_if(cert_value == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
435 retvm_if(cert_type < PMINFO_SET_AUTHOR_ROOT_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
436 retvm_if(cert_type > PMINFO_SET_DISTRIBUTOR2_SIGNER_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
437 pkgmgr_certinfo_x *certinfo = NULL;
438 certinfo = (pkgmgr_certinfo_x *)handle;
439 if (certinfo->cert_info[cert_type])
440 free(certinfo->cert_info[cert_type]);
441 (certinfo->cert_info)[cert_type] = strdup(cert_value);
445 static int _pkginfo_save_cert_info(sqlite3 *db, const char *pkgid,
448 static const char query_insert[] =
449 "INSERT INTO package_cert_info (package, package_count,"
450 " author_root_cert, author_im_cert, author_signer_cert,"
451 " dist_root_cert, dist_im_cert, dist_signer_cert,"
452 " dist2_root_cert, dist2_im_cert, dist2_signer_cert) "
454 " (SELECT cert_id FROM package_cert_index_info"
455 " WHERE cert_info=?),"
456 " (SELECT cert_id FROM package_cert_index_info"
457 " WHERE cert_info=?),"
458 " (SELECT cert_id FROM package_cert_index_info"
459 " WHERE cert_info=?),"
460 " (SELECT cert_id FROM package_cert_index_info"
461 " WHERE cert_info=?),"
462 " (SELECT cert_id FROM package_cert_index_info"
463 " WHERE cert_info=?),"
464 " (SELECT cert_id FROM package_cert_index_info"
465 " WHERE cert_info=?),"
466 " (SELECT cert_id FROM package_cert_index_info"
467 " WHERE cert_info=?),"
468 " (SELECT cert_id FROM package_cert_index_info"
469 " WHERE cert_info=?),"
470 " (SELECT cert_id FROM package_cert_index_info"
471 " WHERE cert_info=?))";
472 static const char query_update[] =
473 "UPDATE package_cert_info "
474 "SET package_count = package_count + 1 "
481 ret = sqlite3_prepare_v2(db, query_insert, strlen(query_insert),
483 if (ret != SQLITE_OK) {
484 _LOGE("prepare error: %s", sqlite3_errmsg(db));
485 return PMINFO_R_ERROR;
489 ret = sqlite3_bind_text(stmt, idx++, pkgid, -1, SQLITE_STATIC);
490 if (ret != SQLITE_OK) {
491 _LOGE("bind failed: %s", sqlite3_errmsg(db));
492 sqlite3_finalize(stmt);
493 return PMINFO_R_ERROR;
496 for (i = 0; i < MAX_CERT_TYPE; i++) {
497 if (sqlite3_bind_text(stmt, idx++, cert_info[i], -1,
499 _LOGE("bind error: %s", sqlite3_errmsg(db));
500 sqlite3_finalize(stmt);
501 return PMINFO_R_ERROR;
505 ret = sqlite3_step(stmt);
506 sqlite3_finalize(stmt);
507 if (ret == SQLITE_CONSTRAINT) {
508 ret = sqlite3_prepare_v2(db, query_update, strlen(query_update),
510 if (ret != SQLITE_OK) {
511 _LOGE("prepare error: %s", sqlite3_errmsg(db));
512 return PMINFO_R_ERROR;
515 if (sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC)) {
516 _LOGE("bind error: %s", sqlite3_errmsg(db));
517 sqlite3_finalize(stmt);
518 return PMINFO_R_ERROR;
521 ret = sqlite3_step(stmt);
522 sqlite3_finalize(stmt);
525 if (ret != SQLITE_DONE) {
526 _LOGE("step error: %s", sqlite3_errmsg(db));
527 return PMINFO_R_ERROR;
533 static int _pkginfo_save_cert_index_info(sqlite3 *db, char *cert_info[])
535 static const char query[] =
536 "INSERT OR REPLACE INTO package_cert_index_info "
537 "(cert_info, cert_id, cert_ref_count) "
540 " (SELECT cert_id FROM package_cert_index_info "
541 " WHERE cert_info=?), "
543 " ((SELECT cert_ref_count FROM package_cert_index_info "
544 " WHERE cert_info=?) + 1), 1))";
550 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
551 if (ret != SQLITE_OK) {
552 _LOGE("prepare error: %s", sqlite3_errmsg(db));
553 return PMINFO_R_ERROR;
556 for (i = 0; i < MAX_CERT_TYPE; i++) {
557 if (cert_info[i] == NULL)
560 ret = sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC);
561 if (ret != SQLITE_OK) {
562 _LOGE("bind failed: %s", sqlite3_errmsg(db));
563 sqlite3_finalize(stmt);
564 return PMINFO_R_ERROR;
566 ret = sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC);
567 if (ret != SQLITE_OK) {
568 _LOGE("bind failed: %s", sqlite3_errmsg(db));
569 sqlite3_finalize(stmt);
570 return PMINFO_R_ERROR;
572 ret = sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC);
573 if (ret != SQLITE_OK) {
574 _LOGE("bind failed: %s", sqlite3_errmsg(db));
575 sqlite3_finalize(stmt);
576 return PMINFO_R_ERROR;
579 ret = sqlite3_step(stmt);
580 if (ret != SQLITE_DONE) {
581 _LOGE("step failed: %s", sqlite3_errmsg(db));
582 sqlite3_finalize(stmt);
583 return PMINFO_R_ERROR;
587 sqlite3_clear_bindings(stmt);
590 sqlite3_finalize(stmt);
595 API int pkgmgrinfo_save_certinfo(const char *pkgid, pkgmgrinfo_instcertinfo_h handle, uid_t uid)
600 pkgmgr_certinfo_x *info = (pkgmgr_certinfo_x *)handle;
602 if (pkgid == NULL || handle == NULL) {
603 _LOGE("invalid parameter");
604 return PMINFO_R_EINVAL;
607 _check_create_cert_db();
609 /* open unified global cert db */
610 dbpath = getUserPkgCertDBPath();
612 return PMINFO_R_ERROR;
614 ret = __open_db(dbpath, &db, SQLITE_OPEN_READWRITE);
615 if (ret != SQLITE_OK) {
616 _LOGE("failed to open db: %d", ret);
618 return PMINFO_R_ERROR;
622 ret = sqlite3_exec(db, "BEGIN DEFERRED", NULL, NULL, NULL);
623 if (ret != SQLITE_OK) {
624 _LOGE("failed to begin transaction");
625 sqlite3_close_v2(db);
626 return PMINFO_R_ERROR;
629 if (_pkginfo_save_cert_index_info(db, info->cert_info)) {
630 _LOGE("failed to save cert index info, rollback now");
631 ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
632 if (ret != SQLITE_OK)
633 LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db));
634 sqlite3_close_v2(db);
635 return PMINFO_R_ERROR;
638 if (_pkginfo_save_cert_info(db, pkgid, info->cert_info)) {
639 _LOGE("failed to save cert info, rollback now");
640 ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
641 if (ret != SQLITE_OK)
642 LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db));
643 sqlite3_close_v2(db);
644 return PMINFO_R_ERROR;
647 ret = sqlite3_exec(db, "COMMIT", NULL, NULL, NULL);
648 if (ret != SQLITE_OK) {
649 _LOGE("failed to commit transaction, rollback now");
650 ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
651 if (ret != SQLITE_OK)
652 LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db));
653 sqlite3_close_v2(db);
654 return PMINFO_R_ERROR;
657 sqlite3_close_v2(db);
662 API int pkgmgrinfo_destroy_certinfo_set_handle(pkgmgrinfo_instcertinfo_h handle)
664 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
666 pkgmgr_certinfo_x *certinfo = NULL;
667 certinfo = (pkgmgr_certinfo_x *)handle;
668 if (certinfo->pkgid) {
669 free(certinfo->pkgid);
670 certinfo->pkgid = NULL;
672 for (i = 0; i < MAX_CERT_TYPE; i++) {
673 if ((certinfo->cert_info)[i]) {
674 free((certinfo->cert_info)[i]);
675 (certinfo->cert_info)[i] = NULL;
683 static int _pkginfo_delete_certinfo(sqlite3 *db, const char *pkgid)
685 static const char query[] =
686 "UPDATE package_cert_info "
687 "SET package_count = package_count - 1 "
692 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
693 if (ret != SQLITE_OK) {
694 _LOGE("prepare error: %s", sqlite3_errmsg(db));
695 return PMINFO_R_ERROR;
698 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC);
699 if (ret != SQLITE_OK) {
700 _LOGE("bind error: %s", sqlite3_errmsg(db));
701 sqlite3_finalize(stmt);
702 return PMINFO_R_ERROR;
705 ret = sqlite3_step(stmt);
706 sqlite3_finalize(stmt);
707 if (ret != SQLITE_DONE) {
708 _LOGE("step error: %s", sqlite3_errmsg(db));
709 return PMINFO_R_ERROR;
715 API int pkgmgrinfo_delete_usr_certinfo(const char *pkgid, uid_t uid)
722 _LOGE("invalid parameter");
723 return PMINFO_R_EINVAL;
726 /* open unified global cert db */
727 dbpath = getUserPkgCertDBPath();
729 return PMINFO_R_ERROR;
731 ret = __open_db(dbpath, &db, SQLITE_OPEN_READWRITE);
732 if (ret != SQLITE_OK) {
733 _LOGE("failed to open db: %d", ret);
735 return PMINFO_R_ERROR;
739 ret = sqlite3_exec(db, "BEGIN DEFERRED", NULL, NULL, NULL);
740 if (ret != SQLITE_OK) {
741 _LOGE("failed to begin transaction");
742 sqlite3_close_v2(db);
743 return PMINFO_R_ERROR;
746 if (_pkginfo_delete_certinfo(db, pkgid)) {
747 _LOGE("failed to delete certinfo of %s, rollback now", pkgid);
748 ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
749 if (ret != SQLITE_OK)
750 LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db));
751 sqlite3_close_v2(db);
752 return PMINFO_R_ERROR;
755 ret = sqlite3_exec(db, "COMMIT", NULL, NULL, NULL);
756 if (ret != SQLITE_OK) {
757 _LOGE("failed to commit transaction, rollback now");
758 ret = sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
759 if (ret != SQLITE_OK)
760 LOGE("Rollback is failed. error(%s)", sqlite3_errmsg(db));
761 sqlite3_close_v2(db);
762 return PMINFO_R_ERROR;
765 sqlite3_close_v2(db);
770 API int pkgmgrinfo_delete_certinfo(const char *pkgid)
772 return pkgmgrinfo_delete_usr_certinfo(pkgid, _getuid());