Refine badge_is_existing, badge_foreach APIs

- Direct DB access APIs could cause security issue
- Get data from data-provider-master

Change-Id: I1540a1a12635986d56ffccb7ad83d2da1f62e868
Signed-off-by: Hyunho Kang <hhstark.kang@samsung.com>

diff --git a/include/badge_db.h b/include/badge_db.h
index 2e2a4ba..3e068f0 100755 (executable)
--- a/include/badge_db.h
+++ b/include/badge_db.h
@@ -39,6 +39,8 @@ int badge_db_get_count(const char *pkgname, unsigned int *count);
 int badge_db_set_display_option(const char *pkgname, const char *caller_pkg, unsigned int is_display);
 int badge_db_get_display_option(const char *pkgname, unsigned int *is_display);
 int badge_db_exec(sqlite3 *db, const char *query, int *num_changes);
+int badge_db_get_list(GList **badge_list);
+int badge_db_is_existing(const char *pkgname, bool *existing);
 
 #ifdef __cplusplus
        }

diff --git a/include/badge_internal.h b/include/badge_internal.h
index d0d24a0..453cf9d 100755 (executable)
--- a/include/badge_internal.h
+++ b/include/badge_internal.h
@@ -47,6 +47,10 @@ extern "C" {
 
 typedef struct _badge_h badge_h;
 
+typedef struct badge_info {
+       char *pkg;
+       unsigned int badge_count;
+} badge_info_s;
 
 /**
  * @internal
@@ -109,6 +113,7 @@ int badge_del_deferred_task(
  * @retval BADGE_ERROR_INVALID_PARAMETER Invalid parameter
  * @retval BADGE_ERROR_PERMISSION_DENIED The application does not have the privilege to call this method
  * @retval BADGE_ERROR_FROM_DB Error from DB
+ * @retval BADGE_ERROR_OUT_OF_MEMORY Out of memory
  * @retval BADGE_ERROR_NOT_EXIST Not exist
  * @retval BADGE_ERROR_SERVICE_NOT_READY Service is not ready
  * @see #badge_error_e
@@ -138,6 +143,8 @@ int _badge_is_existing(const char *pkgname, bool *existing);
 
 int _badge_foreach_existed(badge_foreach_cb callback, void *data);
 
+int _badge_get_list(GList **badge_list);
+
 int _badge_insert(badge_h *badge);
 
 int _badge_remove(const char *caller, const char *pkgname);

diff --git a/include/badge_ipc.h b/include/badge_ipc.h
index cb23ad5..2e785ef 100755 (executable)
--- a/include/badge_ipc.h
+++ b/include/badge_ipc.h
@@ -50,6 +50,9 @@ int badge_ipc_del_deferred_task(void (*badge_add_deferred_task)(void *data));
 int badge_ipc_setting_property_set(const char *pkgname, const char *property, const char *value);
 int badge_ipc_setting_property_get(const char *pkgname, const char *property, char **value);
 
+int badge_ipc_request_get_list(badge_foreach_cb callback, void *data);
+int badge_ipc_request_is_existing(const char *pkgname, bool *existing);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/src/badge.c b/src/badge.c
index 9516d10..8c2a422 100755 (executable)
--- a/src/badge.c
+++ b/src/badge.c
@@ -131,13 +131,17 @@ out:
 EXPORT_API
 int badge_is_existing(const char *app_id, bool *existing)
 {
-       return _badge_is_existing(app_id, existing);
+       return badge_ipc_request_is_existing(app_id, existing);
 }
 
 EXPORT_API
 int badge_foreach(badge_foreach_cb callback, void *user_data)
 {
-       return _badge_foreach_existed(callback, user_data);
+       int result = BADGE_ERROR_NONE;
+       result = badge_ipc_request_get_list(callback, user_data);
+       if (result == BADGE_ERROR_IO_ERROR)
+               result = BADGE_ERROR_FROM_DB;
+       return result;
 }
 
 EXPORT_API
@@ -168,10 +172,15 @@ out:
 EXPORT_API
 int badge_get_count(const char *app_id, unsigned int *count)
 {
+       int result = BADGE_ERROR_NONE;
        if (app_id == NULL || count == NULL)
                return BADGE_ERROR_INVALID_PARAMETER;
 
-       return badge_ipc_request_get_count(app_id, count);
+       result = badge_ipc_request_get_count(app_id, count);
+       if (result == BADGE_ERROR_IO_ERROR)
+               result = BADGE_ERROR_FROM_DB;
+
+       return result;
 }
 
 EXPORT_API
@@ -201,10 +210,15 @@ out:
 EXPORT_API
 int badge_get_display(const char *app_id, unsigned int *is_display)
 {
+       int result = BADGE_ERROR_NONE;
        if (app_id == NULL || is_display == NULL)
                return BADGE_ERROR_INVALID_PARAMETER;
 
-       return badge_ipc_request_get_display(app_id, is_display);
+       result = badge_ipc_request_get_display(app_id, is_display);
+       if (result == BADGE_ERROR_IO_ERROR)
+               result = BADGE_ERROR_FROM_DB;
+
+       return result;
 }
 
 EXPORT_API

diff --git a/src/badge_db.c b/src/badge_db.c
index 2cfd347..67da581 100755 (executable)
--- a/src/badge_db.c
+++ b/src/badge_db.c
@@ -30,6 +30,22 @@
 #include "badge_internal.h"
 
 EXPORT_API
+int badge_db_is_existing(const char *pkgname, bool *existing)
+{
+       int result = BADGE_ERROR_NONE;
+       result = _badge_is_existing(pkgname, existing);
+       return result;
+}
+
+EXPORT_API
+int badge_db_get_list(GList **badge_list)
+{
+       int result = BADGE_ERROR_NONE;
+       result = _badge_get_list(badge_list);
+       return result;
+}
+
+EXPORT_API
 int badge_db_insert(const char *pkgname, const char *writable_pkg, const char *caller)
 {
        int err = BADGE_ERROR_NONE;

diff --git a/src/badge_internal.c b/src/badge_internal.c
index 10c6549..7944558 100755 (executable)
--- a/src/badge_internal.c
+++ b/src/badge_internal.c
@@ -308,7 +308,6 @@ free_and_return:
        return result;
 }
 
-
 int _badge_is_existing(const char *pkgname, bool *existing)
 {
        sqlite3 *db = NULL;
@@ -344,6 +343,83 @@ int _badge_is_existing(const char *pkgname, bool *existing)
        return result;
 }
 
+int _badge_get_list(GList **badge_list)
+{
+       sqlite3 *db = NULL;
+       int result = BADGE_ERROR_NONE;
+       char *sqlbuf = NULL;
+       sqlite3_stmt *stmt = NULL;
+       int sqlret;
+       const char *pkg;
+       unsigned int badge_count;
+       badge_info_s *badge_info;
+
+       sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
+       if (sqlret != SQLITE_OK || !db) {
+               ERR("fail to db_util_open - [%d]", sqlret);
+               return BADGE_ERROR_FROM_DB;
+       }
+
+       sqlbuf = sqlite3_mprintf("SELECT pkgname, badge FROM %q",
+                               BADGE_TABLE_NAME);
+       if (!sqlbuf) {
+               ERR("fail to alloc sql query");
+               result = BADGE_ERROR_OUT_OF_MEMORY;
+               goto free_and_return;
+       }
+
+       sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL);
+       if (sqlret != SQLITE_OK) {
+               ERR("fail to sqlite3_prepare_v2 - [%s]", sqlite3_errmsg(db));
+               ERR("query[%s]", sqlbuf);
+               result = BADGE_ERROR_FROM_DB;
+               goto free_and_return;
+       }
+
+       sqlret = sqlite3_step(stmt);
+       if (sqlret == SQLITE_DONE) {
+               INFO("badge db has no data");
+               result = BADGE_ERROR_NOT_EXIST;
+               goto free_and_return;
+       } else if (sqlret != SQLITE_ROW) {
+               ERR("fail to sqlite3_step : %d", sqlret);
+               result = BADGE_ERROR_FROM_DB;
+               goto free_and_return;
+       }
+
+       do {
+               pkg = (const char *)sqlite3_column_text(stmt, 0);
+               badge_count = (unsigned int)sqlite3_column_int(stmt, 1);
+               if (pkg) {
+                       badge_info = (badge_info_s *)calloc(sizeof(badge_info_s), 1);
+                       if (badge_info == NULL) {
+                               ERR("alloc badge_info fail");
+                               result = BADGE_ERROR_OUT_OF_MEMORY;
+                               break;
+                       }
+                       badge_info->pkg = strdup(pkg);
+                       badge_info->badge_count = badge_count;
+                       *badge_list = g_list_append(*badge_list, badge_info);
+               } else {
+                       ERR("db has invaild data");
+                       result = BADGE_ERROR_FROM_DB;
+               }
+       } while (sqlite3_step(stmt) == SQLITE_ROW);
+
+free_and_return:
+       if (sqlbuf)
+               sqlite3_free(sqlbuf);
+
+       if (stmt)
+               sqlite3_finalize(stmt);
+
+       sqlret = db_util_close(db);
+       if (sqlret != SQLITE_OK)
+               WARN("fail to db_util_close - [%d]", sqlret);
+
+       return result;
+}
+
 int _badge_foreach_existed(badge_foreach_cb callback, void *data)
 {
        sqlite3 *db = NULL;

diff --git a/src/badge_ipc.c b/src/badge_ipc.c
index 7b16c5c..930f305 100755 (executable)
--- a/src/badge_ipc.c
+++ b/src/badge_ipc.c
@@ -467,6 +467,70 @@ int badge_ipc_monitor_fini(void)
        return BADGE_ERROR_NONE;
 }
 
+int badge_ipc_request_is_existing(const char *pkgname, bool *existing)
+{
+       int result;
+       GDBusMessage *reply = NULL;
+       GVariant *body;
+       GVariant *reply_body;
+       int ret_existing;
+
+       result = _dbus_init();
+       if (result != BADGE_ERROR_NONE) {
+               ERR("Can't init dbus %d", result);
+               return result;
+       }
+       body = g_variant_new("(s)", pkgname);
+
+       result = _send_sync_badge(body, &reply, "get_badge_existing");
+       if (result == BADGE_ERROR_NONE) {
+               reply_body = g_dbus_message_get_body(reply);
+               g_variant_get(reply_body, "(i)", &ret_existing);
+               *existing = ret_existing;
+       }
+
+       if (reply)
+               g_object_unref(reply);
+
+       DBG("badge_ipc_request_is_existing done [result: %d]", result);
+       return result;
+}
+
+int badge_ipc_request_get_list(badge_foreach_cb callback, void *data)
+{
+       GDBusMessage *reply = NULL;
+       int result;
+       GVariant *reply_body;
+       GVariant *iter_body;
+       GVariantIter *iter;
+       badge_info_s badge;
+
+       if (callback == NULL)
+               return BADGE_ERROR_INVALID_PARAMETER;
+
+       result = _dbus_init();
+       if (result != BADGE_ERROR_NONE) {
+               ERR("Can't init dbus %d", result);
+               return result;
+       }
+       result = _send_sync_badge(NULL, &reply, "get_list");
+       if (result == BADGE_ERROR_NONE) {
+               reply_body = g_dbus_message_get_body(reply);
+               g_variant_get(reply_body, "(a(v))", &iter);
+               while (g_variant_iter_loop(iter, "(v)", &iter_body)) {
+                       g_variant_get(iter_body, "(&si)", &badge.pkg, &badge.badge_count);
+                       DBG("call calback : %s", badge.pkg);
+                       callback(badge.pkg, badge.badge_count, data);
+               }
+               g_variant_iter_free(iter);
+       }
+
+       if (reply)
+               g_object_unref(reply);
+
+       return result;
+}
+
 int badge_ipc_request_insert(const char *pkgname, const char *writable_pkg, const char *caller)
 {
        int result;
@@ -670,4 +734,3 @@ int badge_ipc_setting_property_get(const char *pkgname, const char *property, ch
        return result;
 }
 
-