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 COALESCE(author_signer_cert, -1) FROM package_cert_info "
65 int certid[2] = {-1, -1};
71 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
72 if (ret != SQLITE_OK) {
73 _LOGE("prepare error: %s", sqlite3_errmsg(db));
74 return PMINFO_R_ERROR;
77 for (i = 0; i < 2; i++) {
78 ret = sqlite3_bind_text(stmt, 1, pkgid[i], -1, SQLITE_STATIC);
79 if (ret != SQLITE_OK) {
80 _LOGE("bind error: %s", sqlite3_errmsg(db));
81 sqlite3_finalize(stmt);
82 return PMINFO_R_ERROR;
85 ret = sqlite3_step(stmt);
86 if (ret == SQLITE_ROW) {
87 _save_column_int(stmt, 0, &certid[i]);
88 } else if (ret != SQLITE_DONE) {
89 _LOGE("step error: %s", sqlite3_errmsg(db));
90 sqlite3_finalize(stmt);
91 return PMINFO_R_ERROR;
95 sqlite3_clear_bindings(stmt);
98 if (certid[0] == -1 && certid[1] == -1)
99 *result = PMINFO_CERT_COMPARE_BOTH_NO_CERT;
100 else if (certid[0] == -1)
101 *result = PMINFO_CERT_COMPARE_LHS_NO_CERT;
102 else if (certid[1] == -1)
103 *result = PMINFO_CERT_COMPARE_RHS_NO_CERT;
104 else if (certid[0] == certid[1])
105 *result = PMINFO_CERT_COMPARE_MATCH;
107 *result = PMINFO_CERT_COMPARE_MISMATCH;
109 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 = __open_db(dbpath, &db, SQLITE_OPEN_READONLY);
133 if (ret != SQLITE_OK) {
134 _LOGE("failed to open db: %d", ret);
136 return PMINFO_R_ERROR;
140 if (_pkginfo_compare_certinfo(db, lhs_package_id, rhs_package_id,
142 _LOGE("failed to compare certinfo");
143 sqlite3_close_v2(db);
144 return PMINFO_R_ERROR;
147 sqlite3_close_v2(db);
152 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)
154 return pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(lhs_package_id, rhs_package_id, _getuid(), compare_result);
157 static int _pkginfo_get_pkgid_from_appid(uid_t uid, const char *appid,
160 static const char query[] =
161 "SELECT package FROM package_app_info WHERE app_id=?";
167 dbpath = getUserPkgParserDBPathUID(uid);
169 return PMINFO_R_ERROR;
171 ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY);
172 if (ret != SQLITE_OK) {
173 _LOGE("failed to open db: %d", ret);
175 return PMINFO_R_ERROR;
179 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
180 if (ret != SQLITE_OK) {
181 _LOGE("prepare error: %s", sqlite3_errmsg(db));
182 sqlite3_close_v2(db);
183 return PMINFO_R_ERROR;
186 ret = sqlite3_bind_text(stmt, 1, appid, -1, SQLITE_STATIC);
187 if (ret != SQLITE_OK) {
188 _LOGE("bind error: %s", sqlite3_errmsg(db));
189 sqlite3_finalize(stmt);
190 sqlite3_close_v2(db);
191 return PMINFO_R_ERROR;
194 ret = sqlite3_step(stmt);
195 if (ret == SQLITE_ROW) {
196 _save_column_str(stmt, 0, pkgid);
198 } else if (ret == SQLITE_DONE) {
199 _LOGI("cannot find pkgid of app %s for uid %d", appid, (int)uid);
200 ret = PMINFO_R_ENOENT;
202 _LOGE("step error: %s", sqlite3_errmsg(db));
203 ret = PMINFO_R_ERROR;
206 sqlite3_finalize(stmt);
207 sqlite3_close_v2(db);
212 API int pkgmgrinfo_pkginfo_compare_usr_app_cert_info(const char *lhs_app_id,
213 const char *rhs_app_id, uid_t uid,
214 pkgmgrinfo_cert_compare_result_type_e *compare_result)
217 char *l_pkgid = NULL;
218 char *r_pkgid = NULL;
220 if (lhs_app_id == NULL || rhs_app_id == NULL ||
221 compare_result == NULL) {
222 _LOGE("invalid parameter");
223 return PMINFO_R_EINVAL;
226 ret = _pkginfo_get_pkgid_from_appid(uid, lhs_app_id, &l_pkgid);
227 if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
228 ret = _pkginfo_get_pkgid_from_appid(GLOBAL_USER, lhs_app_id,
231 if (ret != PMINFO_R_OK)
234 ret = _pkginfo_get_pkgid_from_appid(uid, rhs_app_id, &r_pkgid);
235 if (ret == PMINFO_R_ENOENT && uid != GLOBAL_USER)
236 ret = _pkginfo_get_pkgid_from_appid(GLOBAL_USER, rhs_app_id,
239 if (ret != PMINFO_R_OK) {
244 ret = pkgmgrinfo_pkginfo_compare_usr_pkg_cert_info(l_pkgid, r_pkgid,
245 uid, compare_result);
253 API int pkgmgrinfo_pkginfo_compare_app_cert_info(const char *lhs_app_id,
254 const char *rhs_app_id,
255 pkgmgrinfo_cert_compare_result_type_e *compare_result)
257 return pkgmgrinfo_pkginfo_compare_usr_app_cert_info(lhs_app_id,
258 rhs_app_id, _getuid(), compare_result);
261 static int _pkginfo_get_cert(sqlite3 *db, int cert_id[],
264 static const char query[] =
265 "SELECT cert_info FROM package_cert_index_info WHERE cert_id=?";
270 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
271 if (ret != SQLITE_OK) {
272 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
273 return PMINFO_R_ERROR;
276 for (i = 0; i < MAX_CERT_TYPE; i++) {
277 ret = sqlite3_bind_int(stmt, 1, cert_id[i]);
278 if (ret != SQLITE_OK) {
279 sqlite3_finalize(stmt);
280 _LOGE("bind failed: %s", sqlite3_errmsg(db));
281 return PMINFO_R_ERROR;
284 ret = sqlite3_step(stmt);
285 if (ret == SQLITE_DONE) {
287 sqlite3_clear_bindings(stmt);
289 } else if (ret != SQLITE_ROW) {
290 _LOGE("step failed: %s", sqlite3_errmsg(db));
291 sqlite3_finalize(stmt);
292 return PMINFO_R_ERROR;
295 _save_column_str(stmt, 0, &cert_info[i]);
297 sqlite3_clear_bindings(stmt);
300 sqlite3_finalize(stmt);
305 static int _pkginfo_get_certid(sqlite3 *db, const char *pkgid, int cert_id[])
307 static const char query[] =
308 "SELECT author_root_cert, author_im_cert, author_signer_cert, "
309 "dist_root_cert, dist_im_cert, dist_signer_cert, "
310 "dist2_root_cert, dist2_im_cert, dist2_signer_cert "
311 "FROM package_cert_info WHERE package=?";
316 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
317 if (ret != SQLITE_OK) {
318 _LOGE("prepare failed: %s", sqlite3_errmsg(db));
319 return PMINFO_R_ERROR;
322 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC);
323 if (ret != SQLITE_OK) {
324 _LOGE("bind failed: %s", sqlite3_errmsg(db));
325 sqlite3_finalize(stmt);
326 return PMINFO_R_ERROR;
329 ret = sqlite3_step(stmt);
330 if (ret == SQLITE_DONE) {
331 sqlite3_finalize(stmt);
332 return PMINFO_R_ENOENT;
333 } else if (ret != SQLITE_ROW) {
334 _LOGE("step failed: %s", sqlite3_errmsg(db));
335 sqlite3_finalize(stmt);
336 return PMINFO_R_ERROR;
340 _save_column_int(stmt, idx++, &cert_id[PMINFO_AUTHOR_ROOT_CERT]);
341 _save_column_int(stmt, idx++,
342 &cert_id[PMINFO_AUTHOR_INTERMEDIATE_CERT]);
343 _save_column_int(stmt, idx++, &cert_id[PMINFO_AUTHOR_SIGNER_CERT]);
344 _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR_ROOT_CERT]);
345 _save_column_int(stmt, idx++,
346 &cert_id[PMINFO_DISTRIBUTOR_INTERMEDIATE_CERT]);
347 _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR_SIGNER_CERT]);
348 _save_column_int(stmt, idx++, &cert_id[PMINFO_DISTRIBUTOR2_ROOT_CERT]);
349 _save_column_int(stmt, idx++,
350 &cert_id[PMINFO_DISTRIBUTOR2_INTERMEDIATE_CERT]);
351 _save_column_int(stmt, idx++,
352 &cert_id[PMINFO_DISTRIBUTOR2_SIGNER_CERT]);
354 sqlite3_finalize(stmt);
359 static int _pkginfo_get_certinfo(const char *pkgid, pkgmgr_certinfo_x *info)
365 /* open unified global cert db */
366 dbpath = getUserPkgCertDBPathUID(GLOBAL_USER);
368 return PMINFO_R_ERROR;
370 ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY);
371 if (ret != SQLITE_OK) {
372 _LOGE("failed to open db: %d", ret);
374 return PMINFO_R_ERROR;
378 ret = _pkginfo_get_certid(db, pkgid, info->cert_id);
379 if (ret != PMINFO_R_OK) {
380 sqlite3_close_v2(db);
384 ret = _pkginfo_get_cert(db, info->cert_id, info->cert_info);
385 if (ret != PMINFO_R_OK) {
386 sqlite3_close_v2(db);
390 sqlite3_close_v2(db);
395 API int pkgmgrinfo_pkginfo_load_certinfo(const char *pkgid, pkgmgrinfo_certinfo_h handle, uid_t uid)
398 pkgmgr_certinfo_x *info = (pkgmgr_certinfo_x *)handle;
400 if (pkgid == NULL || handle == NULL) {
401 _LOGE("invalid parameter");
402 return PMINFO_R_EINVAL;
405 ret = _pkginfo_get_certinfo(pkgid, info);
406 if (ret != PMINFO_R_OK)
407 _LOGE("failed to get certinfo of %s ", pkgid);
412 API int pkgmgrinfo_pkginfo_get_cert_value(pkgmgrinfo_certinfo_h handle, pkgmgrinfo_cert_type cert_type, const char **cert_value)
414 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
415 retvm_if(cert_value == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
416 retvm_if(cert_type < PMINFO_AUTHOR_ROOT_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
417 retvm_if(cert_type > PMINFO_DISTRIBUTOR2_SIGNER_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
418 pkgmgr_certinfo_x *certinfo = NULL;
419 certinfo = (pkgmgr_certinfo_x *)handle;
420 if ((certinfo->cert_info)[cert_type])
421 *cert_value = (certinfo->cert_info)[cert_type];
427 API int pkgmgrinfo_pkginfo_destroy_certinfo(pkgmgrinfo_certinfo_h handle)
429 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
431 pkgmgr_certinfo_x *certinfo = NULL;
432 certinfo = (pkgmgr_certinfo_x *)handle;
433 if (certinfo->pkgid) {
434 free(certinfo->pkgid);
435 certinfo->pkgid = NULL;
437 for (i = 0; i < MAX_CERT_TYPE; i++) {
438 if ((certinfo->cert_info)[i]) {
439 free((certinfo->cert_info)[i]);
440 (certinfo->cert_info)[i] = NULL;
448 API int pkgmgrinfo_create_certinfo_set_handle(pkgmgrinfo_instcertinfo_h *handle)
450 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n");
451 pkgmgr_instcertinfo_x *certinfo = NULL;
453 certinfo = calloc(1, sizeof(pkgmgr_instcertinfo_x));
454 retvm_if(certinfo == NULL, PMINFO_R_ERROR, "Malloc Failed\n");
455 *handle = (void *)certinfo;
459 API int pkgmgrinfo_set_cert_value(pkgmgrinfo_instcertinfo_h handle, pkgmgrinfo_instcert_type cert_type, char *cert_value)
461 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
462 retvm_if(cert_value == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
463 retvm_if(cert_type < PMINFO_SET_AUTHOR_ROOT_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
464 retvm_if(cert_type > PMINFO_SET_DISTRIBUTOR2_SIGNER_CERT, PMINFO_R_EINVAL, "Invalid certificate type\n");
465 pkgmgr_instcertinfo_x *certinfo = NULL;
466 certinfo = (pkgmgr_instcertinfo_x *)handle;
467 (certinfo->cert_info)[cert_type] = strdup(cert_value);
471 static int _pkginfo_save_cert_info(sqlite3 *db, const char *pkgid,
474 static const char query_insert[] =
475 "INSERT INTO package_cert_info (package, package_count,"
476 " author_root_cert, author_im_cert, author_signer_cert,"
477 " dist_root_cert, dist_im_cert, dist_signer_cert,"
478 " dist2_root_cert, dist2_im_cert, dist2_signer_cert) "
480 " (SELECT cert_id FROM package_cert_index_info"
481 " WHERE cert_info=?),"
482 " (SELECT cert_id FROM package_cert_index_info"
483 " WHERE cert_info=?),"
484 " (SELECT cert_id FROM package_cert_index_info"
485 " WHERE cert_info=?),"
486 " (SELECT cert_id FROM package_cert_index_info"
487 " WHERE cert_info=?),"
488 " (SELECT cert_id FROM package_cert_index_info"
489 " WHERE cert_info=?),"
490 " (SELECT cert_id FROM package_cert_index_info"
491 " WHERE cert_info=?),"
492 " (SELECT cert_id FROM package_cert_index_info"
493 " WHERE cert_info=?),"
494 " (SELECT cert_id FROM package_cert_index_info"
495 " WHERE cert_info=?),"
496 " (SELECT cert_id FROM package_cert_index_info"
497 " WHERE cert_info=?))";
498 static const char query_update[] =
499 "UPDATE package_cert_info "
500 "SET package_count = package_count + 1 "
507 ret = sqlite3_prepare_v2(db, query_insert, strlen(query_insert),
509 if (ret != SQLITE_OK) {
510 _LOGE("prepare error: %s", sqlite3_errmsg(db));
511 return PMINFO_R_ERROR;
515 ret = sqlite3_bind_text(stmt, idx++, pkgid, -1, SQLITE_STATIC);
516 if (ret != SQLITE_OK) {
517 _LOGE("bind failed: %s", sqlite3_errmsg(db));
518 sqlite3_finalize(stmt);
519 return PMINFO_R_ERROR;
522 for (i = 0; i < MAX_CERT_TYPE; i++) {
523 if (sqlite3_bind_text(stmt, idx++, cert_info[i], -1,
525 _LOGE("bind error: %s", sqlite3_errmsg(db));
526 sqlite3_finalize(stmt);
527 return PMINFO_R_ERROR;
531 ret = sqlite3_step(stmt);
532 sqlite3_finalize(stmt);
533 if (ret == SQLITE_CONSTRAINT) {
534 ret = sqlite3_prepare_v2(db, query_update, strlen(query_update),
536 if (ret != SQLITE_OK) {
537 _LOGE("prepare error: %s", sqlite3_errmsg(db));
538 return PMINFO_R_ERROR;
541 if (sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC)) {
542 _LOGE("bind error: %s", sqlite3_errmsg(db));
543 sqlite3_finalize(stmt);
544 return PMINFO_R_ERROR;
547 ret = sqlite3_step(stmt);
548 sqlite3_finalize(stmt);
551 if (ret != SQLITE_DONE) {
552 _LOGE("step error: %s", sqlite3_errmsg(db));
553 return PMINFO_R_ERROR;
559 static int _pkginfo_save_cert_index_info(sqlite3 *db, char *cert_info[])
561 static const char query[] =
562 "INSERT OR REPLACE INTO package_cert_index_info "
563 "(cert_info, cert_id, cert_ref_count) "
566 " (SELECT cert_id FROM package_cert_index_info "
567 " WHERE cert_info=?), "
569 " ((SELECT cert_ref_count FROM package_cert_index_info "
570 " WHERE cert_info=?) + 1), 1))";
576 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
577 if (ret != SQLITE_OK) {
578 _LOGE("prepare error: %s", sqlite3_errmsg(db));
579 return PMINFO_R_ERROR;
582 for (i = 0; i < MAX_CERT_TYPE; i++) {
583 if (cert_info[i] == NULL)
586 sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC);
587 sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC);
588 sqlite3_bind_text(stmt, idx++, cert_info[i], -1, SQLITE_STATIC);
590 ret = sqlite3_step(stmt);
591 if (ret != SQLITE_DONE) {
592 _LOGE("step failed: %s", sqlite3_errmsg(db));
593 sqlite3_finalize(stmt);
594 return PMINFO_R_ERROR;
598 sqlite3_clear_bindings(stmt);
601 sqlite3_finalize(stmt);
606 API int pkgmgrinfo_save_certinfo(const char *pkgid, pkgmgrinfo_instcertinfo_h handle, uid_t uid)
611 pkgmgr_instcertinfo_x *info = (pkgmgr_instcertinfo_x *)handle;
613 if (pkgid == NULL || handle == NULL) {
614 _LOGE("invalid parameter");
615 return PMINFO_R_EINVAL;
618 _check_create_cert_db();
620 /* open unified global cert db */
621 dbpath = getUserPkgCertDBPathUID(GLOBAL_USER);
623 return PMINFO_R_ERROR;
625 ret = __open_db(dbpath, &db, SQLITE_OPEN_READWRITE);
626 if (ret != SQLITE_OK) {
627 _LOGE("failed to open db: %d", ret);
629 return PMINFO_R_ERROR;
633 ret = sqlite3_exec(db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
634 if (ret != SQLITE_OK) {
635 _LOGE("failed to begin transaction");
636 sqlite3_close_v2(db);
637 return PMINFO_R_ERROR;
640 if (_pkginfo_save_cert_index_info(db, info->cert_info)) {
641 _LOGE("failed to save cert index info, rollback now");
642 sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
643 sqlite3_close_v2(db);
644 return PMINFO_R_ERROR;
647 if (_pkginfo_save_cert_info(db, pkgid, info->cert_info)) {
648 _LOGE("failed to save cert info, rollback now");
649 sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
650 sqlite3_close_v2(db);
651 return PMINFO_R_ERROR;
654 ret = sqlite3_exec(db, "COMMIT", NULL, NULL, NULL);
655 if (ret != SQLITE_OK) {
656 _LOGE("failed to commit transaction, rollback now");
657 sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
658 sqlite3_close_v2(db);
659 return PMINFO_R_ERROR;
662 sqlite3_close_v2(db);
667 API int pkgmgrinfo_destroy_certinfo_set_handle(pkgmgrinfo_instcertinfo_h handle)
669 retvm_if(handle == NULL, PMINFO_R_EINVAL, "Argument supplied is NULL\n");
671 pkgmgr_instcertinfo_x *certinfo = NULL;
672 certinfo = (pkgmgr_instcertinfo_x *)handle;
673 if (certinfo->pkgid) {
674 free(certinfo->pkgid);
675 certinfo->pkgid = NULL;
677 for (i = 0; i < MAX_CERT_TYPE; i++) {
678 if ((certinfo->cert_info)[i]) {
679 free((certinfo->cert_info)[i]);
680 (certinfo->cert_info)[i] = NULL;
688 static int _pkginfo_delete_certinfo(sqlite3 *db, const char *pkgid)
690 static const char query[] =
691 "UPDATE package_cert_info "
692 "SET package_count = package_count - 1 "
697 ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
698 if (ret != SQLITE_OK) {
699 _LOGE("prepare error: %s", sqlite3_errmsg(db));
700 return PMINFO_R_ERROR;
703 ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC);
704 if (ret != SQLITE_OK) {
705 _LOGE("bind error: %s", sqlite3_errmsg(db));
706 sqlite3_finalize(stmt);
707 return PMINFO_R_ERROR;
710 ret = sqlite3_step(stmt);
711 sqlite3_finalize(stmt);
712 if (ret != SQLITE_DONE) {
713 _LOGE("step error: %s", sqlite3_errmsg(db));
714 return PMINFO_R_ERROR;
720 API int pkgmgrinfo_delete_usr_certinfo(const char *pkgid, uid_t uid)
727 _LOGE("invalid parameter");
728 return PMINFO_R_EINVAL;
731 /* open unified global cert db */
732 dbpath = getUserPkgCertDBPathUID(GLOBAL_USER);
734 return PMINFO_R_ERROR;
736 ret = __open_db(dbpath, &db, SQLITE_OPEN_READWRITE);
737 if (ret != SQLITE_OK) {
738 _LOGE("failed to open db: %d", ret);
740 return PMINFO_R_ERROR;
744 ret = sqlite3_exec(db, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
745 if (ret != SQLITE_OK) {
746 _LOGE("failed to begin transaction");
747 sqlite3_close_v2(db);
748 return PMINFO_R_ERROR;
751 if (_pkginfo_delete_certinfo(db, pkgid)) {
752 _LOGE("failed to delete certinfo of %s, rollback now", pkgid);
753 sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
754 sqlite3_close_v2(db);
755 return PMINFO_R_ERROR;
758 ret = sqlite3_exec(db, "COMMIT", NULL, NULL, NULL);
759 if (ret != SQLITE_OK) {
760 _LOGE("failed to commit transaction, rollback now");
761 sqlite3_exec(db, "ROLLBACK", NULL, NULL, NULL);
762 sqlite3_close_v2(db);
763 return PMINFO_R_ERROR;
766 sqlite3_close_v2(db);
771 API int pkgmgrinfo_delete_certinfo(const char *pkgid)
773 return pkgmgrinfo_delete_usr_certinfo(pkgid, _getuid());