Fix static analysis issues

- Unchecked function
  Unreachable code
  Null check after deref

Change-Id: Id926e8efd6469001d18245bc015b3e9fc387ea80
Signed-off-by: mk5004.lee <mk5004.lee@samsung.com>
Signed-off-by: SukHyung, Kang <shine.kang@samsung.com>

diff --git a/parser/complication_parser_plugin.cc b/parser/complication_parser_plugin.cc
index f704a8f..1c50e6d 100644 (file)
--- a/parser/complication_parser_plugin.cc
+++ b/parser/complication_parser_plugin.cc
@@ -308,7 +308,6 @@ static int _parse_support_type(xmlNode* node, sqlite3* db, const char* pkgid,
   int ret;
   int idx;
   int support_type = 0;
-  int result = -1;
 
   xmlNode* tmp;
   xmlNode* tmpdata;
@@ -333,7 +332,7 @@ static int _parse_support_type(xmlNode* node, sqlite3* db, const char* pkgid,
 
   ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
   if (ret != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
+    LOGE("prepare error: %d(%s)", ret, sqlite3_errmsg(db));
     goto out;
   }
 
@@ -395,27 +394,66 @@ static int _parse_support_type(xmlNode* node, sqlite3* db, const char* pkgid,
 
     ret = bundle_encode(default_data, &raw, &len);
     if (ret != BUNDLE_ERROR_NONE) {
-      LOGE("bundle encode error");
+      LOGE("bundle encode error %d", ret);
       goto out;
     }
 
     idx = 1;
 
-    sqlite3_bind_text(stmt, idx++, pkgid, -1, SQLITE_TRANSIENT);
-    sqlite3_bind_text(stmt, idx++, appid, -1, SQLITE_TRANSIENT);
-    sqlite3_bind_text(stmt, idx++, providerid, -1, SQLITE_TRANSIENT);
-    sqlite3_bind_int(stmt, idx++, trusted ? 1 : 0);
-    sqlite3_bind_int(stmt, idx++, period);
-    sqlite3_bind_int(stmt, idx++, support_type);
-    sqlite3_bind_text(stmt, idx, (char*)raw, -1, SQLITE_TRANSIENT);
+    ret = sqlite3_bind_text(stmt, idx++, pkgid, -1, SQLITE_TRANSIENT);
+    if (ret != SQLITE_OK) {
+      LOGE("sqlite3_bind_text() error: %d(%s)", ret, sqlite3_errmsg(db));
+      goto out;
+    }
+
+    ret = sqlite3_bind_text(stmt, idx++, appid, -1, SQLITE_TRANSIENT);
+    if (ret != SQLITE_OK) {
+      LOGE("sqlite3_bind_text() error: %d(%s)", ret, sqlite3_errmsg(db));
+      goto out;
+    }
+
+    ret = sqlite3_bind_text(stmt, idx++, providerid, -1, SQLITE_TRANSIENT);
+    if (ret != SQLITE_OK) {
+      LOGE("sqlite3_bind_text() error: %d(%s)", ret, sqlite3_errmsg(db));
+      goto out;
+    }
+
+    ret = sqlite3_bind_int(stmt, idx++, trusted ? 1 : 0);
+    if (ret != SQLITE_OK) {
+      LOGE("sqlite3_bind_int() error: %d(%s)", ret, sqlite3_errmsg(db));
+      goto out;
+    }
+
+    ret = sqlite3_bind_int(stmt, idx++, period);
+    if (ret != SQLITE_OK) {
+      LOGE("sqlite3_bind_int() error: %d(%s)", ret, sqlite3_errmsg(db));
+      goto out;
+    }
+
+    ret = sqlite3_bind_int(stmt, idx++, support_type);
+    if (ret != SQLITE_OK) {
+      LOGE("sqlite3_bind_int() error: %d(%s)", ret, sqlite3_errmsg(db));
+      goto out;
+    }
+
+    ret = sqlite3_bind_text(stmt, idx, (char*)raw, -1, SQLITE_TRANSIENT);
+    if (ret != SQLITE_OK) {
+      LOGE("sqlite3_bind_text() error: %d(%s)", ret, sqlite3_errmsg(db));
+      goto out;
+    }
 
     ret = sqlite3_step(stmt);
     if (ret != SQLITE_DONE) {
-      LOGE("step error: %s", sqlite3_errmsg(db));
+      LOGE("step error: %d(%s)", ret, sqlite3_errmsg(db));
+      goto out;
+    }
+
+    ret = sqlite3_reset(stmt);
+    if (ret != SQLITE_OK) {
+      LOGE("sqlite3_reset() error: %d", ret);
       goto out;
     }
 
-    sqlite3_reset(stmt);
     sqlite3_clear_bindings(stmt);
 
     if (raw) {
@@ -429,7 +467,7 @@ static int _parse_support_type(xmlNode* node, sqlite3* db, const char* pkgid,
     }
   }
 
-  result = 0;
+  ret = 0;
 out:
   if (default_data)
     bundle_free(default_data);
@@ -440,7 +478,7 @@ out:
   if (stmt)
     sqlite3_finalize(stmt);
 
-  return result;
+  return ret;
 }
 
 static int _parse_label(xmlNode* node, sqlite3* db, const char* providerid) {
@@ -456,7 +494,7 @@ static int _parse_label(xmlNode* node, sqlite3* db, const char* providerid) {
 
   ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
   if (ret != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
+    LOGE("prepare error: %d(%s)", ret, sqlite3_errmsg(db));
     goto out;
   }
 
@@ -464,20 +502,32 @@ static int _parse_label(xmlNode* node, sqlite3* db, const char* providerid) {
 
   idx = 1;
 
-  sqlite3_bind_text(stmt, idx++, providerid, -1, SQLITE_TRANSIENT);
+  ret = sqlite3_bind_text(stmt, idx++, providerid, -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("sqlite3_bind_text() error: %d(%s)", ret, sqlite3_errmsg(db));
+    goto out;
+  }
 
   if (lang)
-    sqlite3_bind_text(stmt, idx++, reinterpret_cast<char*>(lang), -1,
+    ret = sqlite3_bind_text(stmt, idx++, reinterpret_cast<char*>(lang), -1,
                         SQLITE_TRANSIENT);
   else
-    sqlite3_bind_text(stmt, idx++, "No Locale", -1, SQLITE_TRANSIENT);
+    ret = sqlite3_bind_text(stmt, idx++, "No Locale", -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("sqlite3_bind_text() error: %d(%s)", ret, sqlite3_errmsg(db));
+    goto out;
+  }
 
-  sqlite3_bind_text(stmt, idx, reinterpret_cast<char*>(node->children->content),
+  ret = sqlite3_bind_text(stmt, idx, reinterpret_cast<char*>(node->children->content),
                         -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("sqlite3_bind_text() error: %d(%s)", ret, sqlite3_errmsg(db));
+    goto out;
+  }
 
   ret = sqlite3_step(stmt);
   if (ret != SQLITE_DONE) {
-    LOGE("step error: %s", sqlite3_errmsg(db));
+    LOGE("step error: %d(%s)", ret, sqlite3_errmsg(db));
     goto out;
   }
 
@@ -508,23 +558,37 @@ static int _parse_privilege(xmlNode* node, sqlite3* db,
 
   ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
   if (ret != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
+    LOGE("prepare error: %d(%s)", ret, sqlite3_errmsg(db));
     goto out;
   }
 
   for (tmp = node->children; tmp; tmp = tmp->next) {
     if (!xmlStrcasecmp(tmp->name, (const xmlChar*)"privilege")) {
-      sqlite3_bind_text(stmt, 1, providerid, -1, SQLITE_TRANSIENT);
-      sqlite3_bind_text(stmt, 2, (char*)tmp->children->content, -1,
+      ret = sqlite3_bind_text(stmt, 1, providerid, -1, SQLITE_TRANSIENT);
+      if (ret != SQLITE_OK) {
+        LOGE("sqlite3_bind_text() error: %d(%s)", ret, sqlite3_errmsg(db));
+        goto out;
+      }
+
+      ret = sqlite3_bind_text(stmt, 2, (char*)tmp->children->content, -1,
                         SQLITE_TRANSIENT);
+      if (ret != SQLITE_OK) {
+        LOGE("sqlite3_bind_text() error: %d(%s)", ret, sqlite3_errmsg(db));
+        goto out;
+      }
 
       ret = sqlite3_step(stmt);
       if (ret != SQLITE_DONE) {
-        LOGE("step error: %s", sqlite3_errmsg(db));
+        LOGE("step error: %d(%s)", ret, sqlite3_errmsg(db));
+        goto out;
+      }
+
+      ret = sqlite3_reset(stmt);
+      if (ret != SQLITE_OK) {
+        LOGE("sqlite3_reset() error: %d", ret);
         goto out;
       }
 
-      sqlite3_reset(stmt);
       sqlite3_clear_bindings(stmt);
     }
   }
@@ -563,19 +627,34 @@ static int _parse_support_event(xmlNode* node, sqlite3* db,
   if (support_events != 0) {
     ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
     if (ret != SQLITE_OK) {
-      LOGE("prepare error: %s", sqlite3_errmsg(db));
+      LOGE("prepare error: %d(%s)", ret, sqlite3_errmsg(db));
+      goto out;
+    }
+
+    ret = sqlite3_bind_text(stmt, 1, providerid, -1, SQLITE_TRANSIENT);
+    if (ret != SQLITE_OK) {
+      LOGE("sqlite3_bind_text() error: %d(%s)", ret, sqlite3_errmsg(db));
+      goto out;
+    }
+
+    ret = sqlite3_bind_int(stmt, 2, support_events);
+    if (ret != SQLITE_OK) {
+      LOGE("sqlite3_bind_int() error: %d(%s)", ret, sqlite3_errmsg(db));
       goto out;
     }
-    sqlite3_bind_text(stmt, 1, providerid, -1, SQLITE_TRANSIENT);
-    sqlite3_bind_int(stmt, 2, support_events);
 
     ret = sqlite3_step(stmt);
     if (ret != SQLITE_DONE) {
-      LOGE("step error: %s", sqlite3_errmsg(db));
+      LOGE("step error: %d(%s)", ret, sqlite3_errmsg(db));
+      goto out;
+    }
+
+    ret = sqlite3_reset(stmt);
+    if (ret != SQLITE_OK) {
+      LOGE("sqlite3_reset() error: %d", ret);
       goto out;
     }
 
-    sqlite3_reset(stmt);
     sqlite3_clear_bindings(stmt);
   }
 
@@ -599,12 +678,20 @@ static int _parse_setup_appid(sqlite3* db, const char* providerid,
 
   ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
   if (ret != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
+    LOGE("prepare error: %d(%s)", ret, sqlite3_errmsg(db));
     goto out;
   }
 
-  sqlite3_bind_text(stmt, 1, providerid, -1, SQLITE_TRANSIENT);
-  sqlite3_bind_text(stmt, 2, setup_appid, -1, SQLITE_TRANSIENT);
+  ret = sqlite3_bind_text(stmt, 1, providerid, -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("sqlite3_bind_text() error: %d(%s)", ret, sqlite3_errmsg(db));
+    goto out;
+  }
+  ret = sqlite3_bind_text(stmt, 2, setup_appid, -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("sqlite3_bind_text() error: %d(%s)", ret, sqlite3_errmsg(db));
+    goto out;
+  }
 
   ret = sqlite3_step(stmt);
   if (ret != SQLITE_DONE) {
@@ -714,7 +801,9 @@ static int _parse_service_application(xmlNode* node, const char* pkgid) {
       if (providerid == NULL) {
         LOGE("provider-id error");
 
-        sqlite3_exec(db, "ROLLBACK TRANSACTION", NULL, NULL, NULL);
+        if (sqlite3_exec(db, "ROLLBACK TRANSACTION", NULL, NULL, NULL))
+          LOGE("rollback transaction error");
+
         goto out;
       }
 
@@ -725,11 +814,12 @@ static int _parse_service_application(xmlNode* node, const char* pkgid) {
       else
         trusted = false;
 
-      if (_parse_complication(tmp, db, pkgid, appid,
-          providerid, setup_appid, trusted)) {
+      if (_parse_complication(tmp, db, pkgid, appid, providerid, setup_appid,
+          trusted)) {
         LOGE("parse complication error");
 
-        sqlite3_exec(db, "ROLLBACK TRANSACTION", NULL, NULL, NULL);
+        if (sqlite3_exec(db, "ROLLBACK TRANSACTION", NULL, NULL, NULL))
+          LOGE("rollback transaction error");
 
         free(providerid);
 
@@ -819,54 +909,68 @@ static int _remove_complication(sqlite3* db, const char* pkgid) {
   for (i = 0; i < (sizeof(query) / sizeof(*query)); i++) {
     ret = sqlite3_prepare_v2(db, query[i], strlen(query[i]), &stmt, NULL);
     if (ret != SQLITE_OK) {
-      LOGE("prepare error: %s", sqlite3_errmsg(db));
-      return -1;
+      LOGE("prepare error: %d(%s)", ret, sqlite3_errmsg(db));
+      goto out;
     }
 
-    sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
+    ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_TRANSIENT);
+    if (ret != SQLITE_OK) {
+      LOGE("sqlite3_bind_text() error: %d(%s)", ret, sqlite3_errmsg(db));
+      goto out;
+    }
 
     ret = sqlite3_step(stmt);
     if (ret != SQLITE_DONE) {
       LOGE("step error: %s", sqlite3_errmsg(db));
-      sqlite3_finalize(stmt);
-      return -1;
+      goto out;
     }
 
     sqlite3_finalize(stmt);
   }
 
-  return 0;
+  ret = 0;
+
+out:
+  if (stmt)
+    sqlite3_finalize(stmt);
+
+  return ret;
 }
 
 int complication_parser_db_remove_complication(const char* pkgid) {
-  int result = -1;
+  int ret;
   sqlite3* db;
 
   db = open_db(_get_target_uid());
   if (db == NULL)
     return -1;
 
-  if (sqlite3_exec(db, "BEGIN TRANSACTION", NULL, NULL, NULL)) {
-    LOGE("begin transaction error");
+  ret = sqlite3_exec(db, "BEGIN TRANSACTION", NULL, NULL, NULL);
+  if (ret != SQLITE_OK) {
+    LOGE("begin transaction error %d", ret);
     goto out;
   }
 
   if (_remove_complication(db, pkgid)) {
     LOGE("failed to remove complication provider");
 
-    sqlite3_exec(db, "ROLLBACK TRANSACTION", NULL, NULL, NULL);
+    ret = sqlite3_exec(db, "ROLLBACK TRANSACTION", NULL, NULL, NULL);
+    if (ret != SQLITE_OK) {
+      LOGE("rollback transaction error %d", ret);
+    }
     goto out;
   }
 
-  if (sqlite3_exec(db, "END TRANSACTION", NULL, NULL, NULL)) {
-    LOGE("begin transaction error");
+  ret = sqlite3_exec(db, "END TRANSACTION", NULL, NULL, NULL);
+  if (ret != SQLITE_OK) {
+    LOGE("begin transaction error %d", ret);
     goto out;
   }
 
-  result = 0;
+  ret = 0;
 out:
   if (db)
     sqlite3_close_v2(db);
 
-  return result;
+  return ret;
 }

diff --git a/parser/complication_parser_plugin_internal.cc b/parser/complication_parser_plugin_internal.cc
index 5dd2a67..b3957de 100644 (file)
--- a/parser/complication_parser_plugin_internal.cc
+++ b/parser/complication_parser_plugin_internal.cc
@@ -108,25 +108,6 @@ static int _db_busy_handler(void* data, int count) {
   return 0;
 }
 
-static int _create_db(sqlite3* db, const char* path) {
-  int ret;
-
-  if (db)
-    sqlite3_close(db);
-  unlink(path);
-
-  ret = sqlite3_open_v2(path, &db,
-      SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE,
-      NULL);
-  if (ret != SQLITE_OK) {
-    unlink(path);
-    LOGE("create db fail");
-    return -1;
-  }
-
-  return ret;
-}
-
 static int _check_table_exist(sqlite3* db) {
   int ret;
   char* val;
@@ -152,8 +133,7 @@ static int _check_table_exist(sqlite3* db) {
     idx++;
   }
 
-  if (stmt)
-    sqlite3_finalize(stmt);
+  sqlite3_finalize(stmt);
 
   if (idx != COMPLICATION_TBL_COUNT) {
     LOGE("table count not matched");
@@ -190,9 +170,16 @@ int check_db(uid_t uid) {
   LOGD("check db (%s)", path);
   ret = sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE, NULL);
   if (ret != SQLITE_OK) {
-    ret = _create_db(db, path);
+    if (db)
+      sqlite3_close_v2(db);
+    unlink(path);
+
+    ret = sqlite3_open_v2(path, &db,
+        SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE,
+        NULL);
     if (ret != SQLITE_OK) {
       LOGE("Fail to create db %d", ret);
+      unlink(path);
       return -1;
     }
   }
@@ -207,8 +194,7 @@ int check_db(uid_t uid) {
     }
   }
 
-  if (db)
-    sqlite3_close_v2(db);
+  sqlite3_close_v2(db);
 
   return 0;
 }

diff --git a/watchface-complication/db-manager.cc b/watchface-complication/db-manager.cc
index a9cf848..3b2f74f 100644 (file)
--- a/watchface-complication/db-manager.cc
+++ b/watchface-complication/db-manager.cc
@@ -75,6 +75,7 @@ std::unique_ptr<Bundle> DBManager::GetDefaultData(const char* provider_id,
   sqlite3* db;
   int trusted;
   std::string provider_app_id;
+  int ret;
 
   static const char query[] =
     "SELECT trusted, appid, default_data FROM complication_provider "
@@ -92,22 +93,31 @@ std::unique_ptr<Bundle> DBManager::GetDefaultData(const char* provider_id,
     return nullptr;
   }
 
-  sqlite3_bind_text(stmt, 1, provider_id, -1, SQLITE_TRANSIENT);
-  sqlite3_bind_int(stmt, 2, support_type);
+  ret = sqlite3_bind_text(stmt, 1, provider_id, -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("bind error: %s", sqlite3_errmsg(db));
+    goto out;
+  }
+
+  ret = sqlite3_bind_int(stmt, 2, support_type);
+  if (ret != SQLITE_OK) {
+    LOGE("bind error: %s", sqlite3_errmsg(db));
+    goto out;
+  }
 
   if (sqlite3_step(stmt) == SQLITE_ROW) {
     trusted = sqlite3_column_int(stmt, 0);
     provider_app_id = std::string((char*)sqlite3_column_text(stmt, 1));
     if (trusted &&
          util::CheckCertificate(provider_app_id) == false) {
-      sqlite3_finalize(stmt);
-      CloseDB(db);
-      return nullptr;
+      goto out;
     }
     raw_data = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 2));
     default_data = std::unique_ptr<Bundle>(new Bundle(std::string(raw_data)));
   }
 
+ out:
+
   sqlite3_finalize(stmt);
   CloseDB(db);
 
@@ -117,6 +127,7 @@ std::unique_ptr<Bundle> DBManager::GetDefaultData(const char* provider_id,
 int DBManager::GetProviderPeriod(std::string& provider_id, int* period) {
   sqlite3_stmt* stmt = NULL;
   sqlite3* db;
+  int ret;
 
   static const char query[] =
     "SELECT period FROM complication_provider WHERE provider_id=?";
@@ -133,7 +144,13 @@ int DBManager::GetProviderPeriod(std::string& provider_id, int* period) {
     return WATCHFACE_COMPLICATION_ERROR_DB;
   }
 
-  sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
+  ret = sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("bind error: %s", sqlite3_errmsg(db));
+    sqlite3_finalize(stmt);
+    CloseDB(db);
+    return WATCHFACE_COMPLICATION_ERROR_DB;
+  }
 
   /* complication_provider table's default value of period is -1.
   *  So, if nothing specified in period, it will return -1
@@ -153,6 +170,7 @@ bool DBManager::IsProviderExist(std::string& provider_id, int support_type) {
   bool is_exist = false;
   int trusted;
   std::string provider_app_id;
+  int ret;
 
   static const char query[] =
     "SELECT trusted, appid FROM complication_provider "
@@ -170,8 +188,21 @@ bool DBManager::IsProviderExist(std::string& provider_id, int support_type) {
     return false;
   }
 
-  sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
-  sqlite3_bind_int(stmt, 2, support_type);
+  ret = sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("bind error: %s", sqlite3_errmsg(db));
+    sqlite3_finalize(stmt);
+    CloseDB(db);
+    return false;
+  }
+
+  ret = sqlite3_bind_int(stmt, 2, support_type);
+  if (ret != SQLITE_OK) {
+    LOGE("bind error: %s", sqlite3_errmsg(db));
+    sqlite3_finalize(stmt);
+    CloseDB(db);
+    return false;
+  }
 
   if (sqlite3_step(stmt) == SQLITE_ROW) {
     trusted = sqlite3_column_int(stmt, 0);
@@ -194,6 +225,7 @@ std::string DBManager::GetProviderAppId(const char* provider_id) {
   sqlite3* db;
   int trusted;
   std::string provider_app_id;
+  int ret;
 
   static const char query[] =
     "SELECT trusted, appid FROM complication_provider WHERE provider_id=?";
@@ -210,7 +242,13 @@ std::string DBManager::GetProviderAppId(const char* provider_id) {
     return std::string();
   }
 
-  sqlite3_bind_text(stmt, 1, provider_id, -1, SQLITE_TRANSIENT);
+  ret = sqlite3_bind_text(stmt, 1, provider_id, -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("bind error: %s", sqlite3_errmsg(db));
+    sqlite3_finalize(stmt);
+    CloseDB(db);
+    return std::string();
+  }
 
   if (sqlite3_step(stmt) == SQLITE_ROW) {
     trusted = sqlite3_column_int(stmt, 0);
@@ -238,6 +276,7 @@ DBManager::GetProviderListWithTypes(int supported_types) {
   std::list<std::unique_ptr<DBManager::ProviderInfo>> provider_list;
   int trusted;
   std::string provider_app_id;
+  int ret;
 
   static const char query[] =
     "SELECT trusted, appid, provider_id, support_type FROM complication_provider "
@@ -255,7 +294,14 @@ DBManager::GetProviderListWithTypes(int supported_types) {
     return provider_list;
   }
 
-  sqlite3_bind_int(stmt, 1, supported_types);
+  ret = sqlite3_bind_int(stmt, 1, supported_types);
+  if (ret != SQLITE_OK) {
+    LOGE("bind error: %s", sqlite3_errmsg(db));
+    sqlite3_finalize(stmt);
+    CloseDB(db);
+    return provider_list;
+  }
+
   while (sqlite3_step(stmt) == SQLITE_ROW) {
     trusted = sqlite3_column_int(stmt, 0);
     provider_app_id = std::string((char*)sqlite3_column_text(stmt, 1));
@@ -268,9 +314,7 @@ DBManager::GetProviderListWithTypes(int supported_types) {
         std::unique_ptr<ProviderInfo>(new ProviderInfo(provider_id, type)));
   }
 
-  if (stmt)
-    sqlite3_finalize(stmt);
-
+  sqlite3_finalize(stmt);
   CloseDB(db);
 
   return std::move(provider_list);
@@ -282,6 +326,7 @@ std::list<std::string> DBManager::GetProviderListWithAppId(
   sqlite3_stmt* stmt;
   sqlite3* db;
   std::list<std::string> provider_list;
+  int ret;
 
   static const char query[] =
     "SELECT DISTINCT provider_id FROM complication_provider WHERE appid=?";
@@ -298,7 +343,13 @@ std::list<std::string> DBManager::GetProviderListWithAppId(
     return provider_list;
   }
 
-  sqlite3_bind_text(stmt, 1, provider_app_id, -1, SQLITE_TRANSIENT);
+  ret = sqlite3_bind_text(stmt, 1, provider_app_id, -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("bind error: %s", sqlite3_errmsg(db));
+    sqlite3_finalize(stmt);
+    CloseDB(db);
+    return provider_list;
+  }
 
   while (sqlite3_step(stmt) == SQLITE_ROW) {
     provider = (char*)sqlite3_column_text(stmt, 0);
@@ -317,6 +368,7 @@ int DBManager::GetSupportTypes(std::string& provider_id, int* types) {
   sqlite3* db;
   int trusted;
   std::string provider_app_id;
+  int ret;
 
   static const char query[] =
       "SELECT trusted, appid, SUM(support_type) FROM complication_provider "
@@ -334,7 +386,13 @@ int DBManager::GetSupportTypes(std::string& provider_id, int* types) {
     return WATCHFACE_COMPLICATION_ERROR_DB;
   }
 
-  sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
+  ret = sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("bind error: %s", sqlite3_errmsg(db));
+    sqlite3_finalize(stmt);
+    CloseDB(db);
+    return WATCHFACE_COMPLICATION_ERROR_DB;
+  }
 
   if (sqlite3_step(stmt) == SQLITE_ROW) {
     trusted = sqlite3_column_int(stmt, 0);
@@ -359,6 +417,7 @@ std::list<std::string> DBManager::GetRequiredPrivilegeList(
   sqlite3_stmt* stmt;
   sqlite3* db;
   std::list<std::string> privlege_list;
+  int ret;
 
   static const char query[] =
     "SELECT DISTINCT privilege FROM provider_privilege WHERE provider_id=?";
@@ -375,7 +434,13 @@ std::list<std::string> DBManager::GetRequiredPrivilegeList(
     return privlege_list;
   }
 
-  sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
+  ret = sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("bind error: %s", sqlite3_errmsg(db));
+    sqlite3_finalize(stmt);
+    CloseDB(db);
+    return privlege_list;
+  }
 
   while (sqlite3_step(stmt) == SQLITE_ROW) {
     privlege = (char*)sqlite3_column_text(stmt, 0);
@@ -399,6 +464,7 @@ int DBManager::GetRequiredSupportEvents(
   sqlite3_stmt* stmt;
   sqlite3* db;
   std::list<std::string> privlege_list;
+  int ret;
 
   static const char query[] =
     "SELECT support_events FROM provider_support_events WHERE provider_id=?";
@@ -415,7 +481,13 @@ int DBManager::GetRequiredSupportEvents(
     return -1;
   }
 
-  sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
+  ret = sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("bind error: %s", sqlite3_errmsg(db));
+    sqlite3_finalize(stmt);
+    CloseDB(db);
+    return -1;
+  }
 
   if (sqlite3_step(stmt) == SQLITE_ROW)
     support_events = sqlite3_column_int(stmt, 0);
@@ -474,6 +546,7 @@ std::string DBManager::GetLabel(const char* provider_id) {
   sqlite3_stmt *stmt;
   sqlite3* db;
   char* locale = NULL;
+  int ret;
 
   static const char query[] =
     "SELECT provider_label FROM provider_localized_info "
@@ -498,8 +571,23 @@ std::string DBManager::GetLabel(const char* provider_id) {
     return std::string();
   }
 
-  sqlite3_bind_text(stmt, 1, provider_id, -1, SQLITE_TRANSIENT);
-  sqlite3_bind_text(stmt, 2, locale, -1, SQLITE_TRANSIENT);
+  ret = sqlite3_bind_text(stmt, 1, provider_id, -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("bind error: %s", sqlite3_errmsg(db));
+    sqlite3_finalize(stmt);
+    CloseDB(db);
+    free(locale);
+    return std::string();
+  }
+
+  ret = sqlite3_bind_text(stmt, 2, locale, -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("bind error: %s", sqlite3_errmsg(db));
+    sqlite3_finalize(stmt);
+    CloseDB(db);
+    free(locale);
+    return std::string();
+  }
 
   if (sqlite3_step(stmt) == SQLITE_ROW)
     label = std::string(reinterpret_cast<const char*>(
@@ -528,6 +616,7 @@ std::string DBManager::GetSetupAppId(const char* provider_id) {
   std::string setup_appid;
   sqlite3_stmt* stmt;
   sqlite3* db;
+  int ret;
 
   static const char query[] =
     "SELECT DISTINCT setup_appid FROM provider_setup_appid WHERE provider_id=?";
@@ -544,7 +633,13 @@ std::string DBManager::GetSetupAppId(const char* provider_id) {
     return std::string();
   }
 
-  sqlite3_bind_text(stmt, 1, provider_id, -1, SQLITE_TRANSIENT);
+  ret = sqlite3_bind_text(stmt, 1, provider_id, -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("bind error: %s", sqlite3_errmsg(db));
+    sqlite3_finalize(stmt);
+    CloseDB(db);
+    return std::string();
+  }
 
   if (sqlite3_step(stmt) == SQLITE_ROW)
     setup_appid = std::string(reinterpret_cast<const char*>(
@@ -603,7 +698,13 @@ int DBManager::GetTrustedInfo(std::string& provider_id, bool* trusted) {
     return WATCHFACE_COMPLICATION_ERROR_DB;
   }
 
-  sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
+  ret = sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
+  if (ret != SQLITE_OK) {
+    LOGE("bind error: %s", sqlite3_errmsg(db));
+    sqlite3_finalize(stmt);
+    CloseDB(db);
+    return WATCHFACE_COMPLICATION_ERROR_DB;
+  }
 
   if (sqlite3_step(stmt) == SQLITE_ROW) {
     trusted_info = sqlite3_column_int(stmt, 0);