#define DATABASE_FULL_PATH "/opt/usr/dbspace/.ua-manager-data.db"
#endif
+/* Helper macros */
+#define EXEC(error_code, command, handle_error) do { \
+ if (error_code != command) { \
+ FUNC_EXIT; \
+ goto handle_error; \
+ } \
+} while (0)
+
+#define PREPARE_DELETE(rc, db, stm, query, finalize) do { \
+ rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
+ if (rc != SQLITE_OK) { \
+ stm = NULL; \
+ finalize(); \
+ UAM_ERR("Failed to prepare \"%s\" query" \
+ , query); \
+ return rc; \
+ } \
+} while (0)
+
+#define PREPARE_SELECT(rc, db, stm, query, finalize) do { \
+ rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
+ if (rc != SQLITE_OK) { \
+ stm = NULL; \
+ finalize(); \
+ UAM_ERR("Failed to prepare \"%s\" query" \
+ , query); \
+ return rc; \
+ } \
+} while (0)
+
+#define PREPARE_UPDATE(rc, db, stm, query, finalize) do { \
+ rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
+ if (rc != SQLITE_OK) { \
+ stm = NULL; \
+ finalize(); \
+ UAM_ERR("Failed to prepare \"%s\" query" \
+ , query); \
+ return rc; \
+ } \
+} while (0)
+
+#define PREPARE_INSERT(rc, db, stm, query, finalize) do { \
+ rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
+ if (rc != SQLITE_OK) { \
+ stm = NULL; \
+ finalize(); \
+ UAM_ERR("Failed to prepare \"%s\" query" \
+ , query); \
+ return rc; \
+ } \
+} while (0)
+
+#define FINALIZE(stm) do { \
+ if (stm) { \
+ sqlite3_finalize(stm); \
+ stm = NULL; \
+ } \
+} while (0)
+
+#define DB_ACTION(command, error_code, handle_error) do { \
+ if ((command) != SQLITE_OK) { \
+ error_code = UAM_ERROR_DB_FAILED; \
+ FUNC_EXIT; \
+ goto handle_error; \
+ } \
+} while (0)
+
/* Helper Functions */
int _ua_db_initialize_once(void);
/* select operations */
GSList *_ua_device_db_get_all_devices(void);
-int _ua_device_db_get_device(char *device_id, int tech_type, char *address,
- db_device_info_t *info);
-int _uam_db_get_device_number(const char *device_id, int tech_type, const char *address, int *device_number);
+int _ua_device_db_get_device(
+ char *device_id, int tech_type, char *address, db_device_info_t *info);
+int _uam_db_get_device_number(
+ const char *device_id, int tech_type, const char *address, int *device_number);
/* delete operations */
int _ua_device_db_clear(void);
-int _ua_device_db_delete_device_info(const char *device_id, int tech_type, const char *address);
+int _ua_device_db_delete_device_info(
+ const char *device_id, int tech_type, const char *address);
/* insert */
-int _ua_device_db_insert_device_info(int user_id, const uam_device_info_s *dev_info,
- int presence_state, long timestamp);
+int _ua_device_db_insert_device_info(
+ int user_id, const uam_device_info_s *dev_info, int presence_state, long timestamp);
/* update */
-int _ua_device_db_update_device_timestamp(char *device_id, int tech_type,
- char *address, long timestamp);
-int _ua_device_db_update_device_presence(char *device_id, int tech_type, char *address,
- int presence_state);
-int _ua_device_db_update_device_ip_address(char *device_id, int tech_type, char *address,
- char *ip_address);
-int _ua_device_db_update_device_discriminant(char *device_id, int tech_type,
- char *address, char discriminant);
+int _ua_device_db_update_device_timestamp(
+ char *device_id, int tech_type, char *address, long timestamp);
+int _ua_device_db_update_device_presence(
+ char *device_id, int tech_type, char *address, int presence_state);
+int _ua_device_db_update_device_ip_address(
+ char *device_id, int tech_type, char *address, char *ip_address);
+int _ua_device_db_update_device_discriminant(
+ char *device_id, int tech_type, char *address, char discriminant);
/* SERVICE QUERIES */
typedef struct {
int _ua_service_db_clear(void);
/* insert */
-int _uam_db_insert_service_info(int *service_number, const char *service_name, int cycle);
+int _uam_db_insert_service_info(
+ int *service_number, const char *service_name, int cycle);
/* update */
int _uam_db_update_service_cycle(const char *service_name, int cycle);
/* select operations */
GSList *_uam_db_get_service(int device_number);
-GSList *_uam_db_get_device_services(const char *device_id, int tech_type, const char *address);
+GSList *_uam_db_get_device_services(
+ const char *device_id, int tech_type, const char *address);
/* delete operations */
int _ua_device_service_db_clear(void);
int _uam_db_delete_service_number(int service_number);
-int _uam_db_delete_device_service_number(int device_number, int service_number);
+int _uam_db_delete_device_service_number(
+ int device_number, int service_number);
int _uam_db_delete_device_service(const char *service_name);
int _uam_db_delete_device_service_info(const char *device_id, int tech_type,
const char *address, const char *service_name);
/* insert */
int _uam_db_insert_service(int device_number, int service_number);
int _uam_db_insert_device_service_info(const char *device_id, int tech_type,
- const char *address, const char *service_name, int cycle);
-
+ const char *address, const char *service_name, int cycle);
#ifdef __cplusplus
}
return 1;
}
-static int __uam_db_check_integrity_cb(void *err, int count, char **data, char **columns)
+static int __uam_db_check_integrity_cb(
+ void *err, int count, char **data, char **columns)
{
FUNC_ENTRY;
int i;
for (i = 0; i < count; i++) {
UAM_DBG("%s = %s\n", columns[i], data[i] ? data[i] : "NULL");
- if (!g_strcmp0(columns[i], "integrity_check") && !g_strcmp0(data[i], "ok")) return 0;
+ if (!g_strcmp0(columns[i], "integrity_check") && !g_strcmp0(data[i], "ok"))
+ return 0;
}
return 1;
}
-static int __uam_db_check_table_cb(void *err, int count, char **data, char **columns)
+static int __uam_db_check_table_cb(
+ void *err, int count, char **data, char **columns)
{
FUNC_ENTRY;
int i;
for (i = 0; i < count; i++) {
UAM_DBG("%s = %s\n", columns[i], data[i] ? data[i] : "NULL");
- if (!g_strcmp0(columns[i], "count") && !g_strcmp0(data[i], "1")) return 0;
+ if (!g_strcmp0(columns[i], "count") && !g_strcmp0(data[i], "1"))
+ return 0;
}
return 1;
}
res = sqlite3_open(DATABASE_FULL_PATH, &database);
if (res != SQLITE_OK) {
- UAM_ERR("Error in opening database %s: %s", DATABASE_FULL_PATH, sqlite3_errmsg(database));
+ UAM_ERR("Error in opening database %s: %s",
+ DATABASE_FULL_PATH, sqlite3_errmsg(database));
FUNC_EXIT;
return UAM_ERROR_DB_FAILED;
}
char *error = NULL;
sql_ret = sqlite3_open_v2(DATABASE_FULL_PATH, &(database),
- SQLITE_OPEN_FULLMUTEX | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
+ SQLITE_OPEN_FULLMUTEX | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
if (SQLITE_OK != sql_ret) {
UAM_ERR("sqlite3_open_v2 failed, (%d)", sql_ret);
return UAM_ERROR_DB_FAILED;
#define SELECT_ALL_DEVICES "SELECT device_id, tech_type, address, " \
"ip_address, timestamp, presence_state, os_type, " \
"user_id, discriminant FROM devices"
+
#define SELECT_DEVICE "SELECT device_id, tech_type, address, " \
"ip_address, timestamp, presence_state, os_type, " \
- "user_id, discriminant FROM devices WHERE device_id = ? AND tech_type = ? AND address = ?"
+ "user_id, discriminant FROM devices WHERE device_id = ? AND tech_type = ? " \
+ "AND address = ?"
+
#define SELECT_DEVICE_NUMBER "SELECT device_number FROM devices " \
"WHERE device_id = ? AND tech_type = ? AND address = ?"
+
#define SELECT_MAX_DEVICE_NUMBER "SELECT MAX(device_number) FROM devices"
#define INSERT_DEVICE "insert into devices " \
#define UPDATE_TIMESTAMP "UPDATE devices " \
"SET timestamp = ? WHERE device_id = ? AND tech_type = ? AND address = ?"
+
#define UPDATE_PRESENCE "UPDATE devices " \
"SET presence_state = ? WHERE device_id = ? AND tech_type = ? AND address = ?"
+
#define UPDATE_IP_ADDRESS "UPDATE devices " \
"SET ip_address = ? WHERE device_id = ? AND tech_type = ? AND address = ?"
+
#define UPDATE_DISCRIMINANT "UPDATE devices " \
"SET discriminant = ? WHERE device_id = ? AND tech_type = ? AND address = ?"
#define DELETE_DEVICE_INFO "delete from devices " \
"WHERE device_id = ? AND tech_type = ? AND address = ?"
-#ifndef DATABASE_FULL_PATH
-#define DATABASE_FULL_PATH "/opt/usr/dbspace/.ua-manager-data.db"
-#endif
-
-#define SQLITE_BUSY_TIMEOUT 500000
-
static void __ua_device_finalize_delete(void);
-#define EXEC(error_code, command) do { \
- if (error_code != command) { \
- FUNC_EXIT; \
- goto handle_error; \
- } \
-} while (0)
-
-#define PREPARE_DELETE(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- __ua_device_finalize_delete(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-
-static void __ua_device_finalize_select(void);
-
-#define PREPARE_SELECT(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- __ua_device_finalize_select(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-
-static void _ua_device_finalize_update(void);
-
-#define PREPARE_UPDATE(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- _ua_device_finalize_update(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-
-static void __ua_device_finalize_insert(void);
-
-#define PREPARE_INSERT(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- __ua_device_finalize_insert(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-
-#define FINALIZE(stm) do { \
- if (stm) { \
- sqlite3_finalize(stm); \
- stm = NULL; \
- } \
-} while (0)
-
-#define DB_ACTION(command) do { \
- if ((command) != SQLITE_OK) { \
- error_code = UAM_ERROR_DB_FAILED; \
- FUNC_EXIT; \
- goto handle_error; \
- } \
-} while (0)
-
/* DELETE statements */
static sqlite3_stmt *delete_all_devices;
static sqlite3_stmt *delete_device_info;
extern sqlite3 *database;
static int max_device_number;
+static void __ua_device_finalize_delete(void)
+{
+ FUNC_ENTRY;
+
+ FINALIZE(delete_all_devices);
+ FINALIZE(delete_device_info);
+
+ FUNC_EXIT;
+}
+
+static void __ua_device_finalize_select(void)
+{
+ FUNC_ENTRY;
+
+ FINALIZE(select_all_devices);
+ FINALIZE(select_device);
+ FINALIZE(select_device_number);
+ FINALIZE(select_max_device_number);
+
+ FUNC_EXIT;
+}
+
+static void __ua_device_finalize_insert(void)
+{
+ FUNC_ENTRY;
+
+ FINALIZE(insert_device_info);
+
+ FUNC_EXIT;
+}
+
+static void __ua_device_finalize_update(void)
+{
+ FUNC_ENTRY;
+
+ FINALIZE(update_timestamp);
+ FINALIZE(update_presence);
+ FINALIZE(update_ip_address);
+ FINALIZE(update_discriminant);
+
+ FUNC_EXIT;
+}
+
static int __ua_device_prepare_delete(sqlite3 *db)
{
FUNC_ENTRY;
return SQLITE_OK;
}
- PREPARE_DELETE(delete_all_devices, DELETE_ALL_DEVICES);
- PREPARE_DELETE(delete_device_info, DELETE_DEVICE_INFO);
+ PREPARE_DELETE(rc, db, delete_all_devices,
+ DELETE_ALL_DEVICES, __ua_device_finalize_delete);
+ PREPARE_DELETE(rc, db, delete_device_info,
+ DELETE_DEVICE_INFO, __ua_device_finalize_delete);
initialized = 1;
FUNC_EXIT;
return SQLITE_OK;
}
- PREPARE_SELECT(select_all_devices, SELECT_ALL_DEVICES);
- PREPARE_SELECT(select_device, SELECT_DEVICE);
- PREPARE_SELECT(select_device_number, SELECT_DEVICE_NUMBER);
- PREPARE_SELECT(select_max_device_number, SELECT_MAX_DEVICE_NUMBER);
+ PREPARE_SELECT(rc, db, select_all_devices,
+ SELECT_ALL_DEVICES, __ua_device_finalize_select);
+ PREPARE_SELECT(rc, db, select_device,
+ SELECT_DEVICE, __ua_device_finalize_select);
+ PREPARE_SELECT(rc, db, select_device_number,
+ SELECT_DEVICE_NUMBER, __ua_device_finalize_select);
+ PREPARE_SELECT(rc, db, select_max_device_number,
+ SELECT_MAX_DEVICE_NUMBER, __ua_device_finalize_select);
initialized = 1;
FUNC_EXIT;
return SQLITE_OK;
}
- PREPARE_UPDATE(update_timestamp, UPDATE_TIMESTAMP);
- PREPARE_UPDATE(update_presence, UPDATE_PRESENCE);
- PREPARE_UPDATE(update_ip_address, UPDATE_IP_ADDRESS);
- PREPARE_UPDATE(update_discriminant, UPDATE_DISCRIMINANT);
+ PREPARE_UPDATE(rc, db, update_timestamp,
+ UPDATE_TIMESTAMP, __ua_device_finalize_update);
+ PREPARE_UPDATE(rc, db, update_presence,
+ UPDATE_PRESENCE, __ua_device_finalize_update);
+ PREPARE_UPDATE(rc, db, update_ip_address,
+ UPDATE_IP_ADDRESS, __ua_device_finalize_update);
+ PREPARE_UPDATE(rc, db, update_discriminant,
+ UPDATE_DISCRIMINANT, __ua_device_finalize_update);
initialized = 1;
FUNC_EXIT;
return SQLITE_OK;
}
- PREPARE_INSERT(insert_device_info, INSERT_DEVICE);
+ PREPARE_INSERT(rc, db, insert_device_info,
+ INSERT_DEVICE, __ua_device_finalize_insert);
initialized = 1;
FUNC_EXIT;
return UAM_ERROR_DB_FAILED;
}
- DB_ACTION(__ua_device_prepare_delete(db));
- DB_ACTION(__ua_device_prepare_select(db));
- DB_ACTION(__ua_device_prepare_update(db));
- DB_ACTION(__ua_device_prepare_insert(db));
+ DB_ACTION(__ua_device_prepare_delete(db), error_code, handle_error);
+ DB_ACTION(__ua_device_prepare_select(db), error_code, handle_error);
+ DB_ACTION(__ua_device_prepare_update(db), error_code, handle_error);
+ DB_ACTION(__ua_device_prepare_insert(db), error_code, handle_error);
handle_error:
return error_code;
}
-static void __ua_device_finalize_delete(void)
-{
- FUNC_ENTRY;
-
- FINALIZE(delete_all_devices);
- FINALIZE(delete_device_info);
-
- FUNC_EXIT;
-}
-
-static void __ua_device_finalize_select(void)
-{
- FUNC_ENTRY;
-
- FINALIZE(select_all_devices);
- FINALIZE(select_device);
- FINALIZE(select_device_number);
- FINALIZE(select_max_device_number);
-
- FUNC_EXIT;
-}
-
-static void __ua_device_finalize_insert(void)
-{
- FUNC_ENTRY;
-
- FINALIZE(insert_device_info);
-
- FUNC_EXIT;
-}
-
-static void _ua_device_finalize_update(void)
-{
- FUNC_ENTRY;
-
- FINALIZE(update_timestamp);
- FINALIZE(update_presence);
- FINALIZE(update_ip_address);
- FINALIZE(update_discriminant);
-
- FUNC_EXIT;
-}
-
static void __ua_device_table_devicesinfo_finalize(void)
{
FUNC_ENTRY;
{
FUNC_ENTRY;
- EXEC(UAM_ERROR_NONE, __ua_device_table_devicesinfo_prepare(database));
+ EXEC(UAM_ERROR_NONE, __ua_device_table_devicesinfo_prepare(database), handle_error);
if (_uam_db_get_max_device_number() != UAM_ERROR_NONE)
goto handle_error;
return UAM_ERROR_DB_FAILED;
}
-int _ua_device_db_update_device_ip_address(char *device_id, int tech_type, char *address,
+int _ua_device_db_update_device_ip_address(char *device_id, int tech_type,
+ char *address,
char *ip_address)
{
int error_code = UAM_ERROR_NONE;
retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
retv_if(NULL == ip_address, UAM_ERROR_INVALID_PARAMETER);
- DB_ACTION(sqlite3_bind_text(stmt, 1, ip_address, -1, SQLITE_TRANSIENT));
- DB_ACTION(sqlite3_bind_text(stmt, 2, device_id, -1, SQLITE_TRANSIENT));
- DB_ACTION(sqlite3_bind_int(stmt, 3, tech_type));
- DB_ACTION(sqlite3_bind_text(stmt, 4, address, -1, SQLITE_TRANSIENT));
+ DB_ACTION(sqlite3_bind_text(stmt, 1, ip_address, -1, SQLITE_TRANSIENT),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 2, device_id, -1, SQLITE_TRANSIENT),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 3, tech_type),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 4, address, -1, SQLITE_TRANSIENT),
+ error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to update ip address: %s",
return error_code;
}
-int _ua_device_db_update_device_presence(char *device_id, int tech_type, char *address,
- int presence_state)
+int _ua_device_db_update_device_presence(char *device_id, int tech_type,
+ char *address, int presence_state)
{
int error_code = UAM_ERROR_NONE;
sqlite3_stmt *stmt = update_presence;
retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
- DB_ACTION(sqlite3_bind_int(stmt, 1, presence_state));
- DB_ACTION(sqlite3_bind_text(stmt, 2, device_id, -1, SQLITE_TRANSIENT));
- DB_ACTION(sqlite3_bind_int(stmt, 3, tech_type));
- DB_ACTION(sqlite3_bind_text(stmt, 4, address, -1, SQLITE_TRANSIENT));
+ DB_ACTION(sqlite3_bind_int(stmt, 1, presence_state),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 2, device_id, -1, SQLITE_TRANSIENT),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 3, tech_type),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 4, address, -1, SQLITE_TRANSIENT),
+ error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to update presence: %s",
retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
- DB_ACTION(sqlite3_bind_int64(stmt, 1, timestamp));
- DB_ACTION(sqlite3_bind_text(stmt, 2, device_id, -1, SQLITE_TRANSIENT));
- DB_ACTION(sqlite3_bind_int(stmt, 3, tech_type));
- DB_ACTION(sqlite3_bind_text(stmt, 4, address, -1, SQLITE_TRANSIENT));
+ DB_ACTION(sqlite3_bind_int64(stmt, 1, timestamp),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 2, device_id, -1, SQLITE_TRANSIENT),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 3, tech_type),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 4, address, -1, SQLITE_TRANSIENT),
+ error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to update device timestamp: %s",
retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
- DB_ACTION(sqlite3_bind_int(stmt, 1, discriminant));
- DB_ACTION(sqlite3_bind_text(stmt, 2, device_id, -1, SQLITE_TRANSIENT));
- DB_ACTION(sqlite3_bind_int(stmt, 3, tech_type));
- DB_ACTION(sqlite3_bind_text(stmt, 4, address, -1, SQLITE_TRANSIENT));
+ DB_ACTION(sqlite3_bind_int(stmt, 1, discriminant),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 2, device_id, -1, SQLITE_TRANSIENT),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 3, tech_type),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 4, address, -1, SQLITE_TRANSIENT),
+ error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to update device discriminant: %s",
return error_code;
}
-int _ua_device_db_insert_device_info(int user_id, const uam_device_info_s *dev_info,
- int presence_state, long timestamp)
+int _ua_device_db_insert_device_info(int user_id,
+ const uam_device_info_s *dev_info, int presence_state, long timestamp)
{
FUNC_ENTRY;
int error_code = UAM_ERROR_NONE;
timestamp, presence_state, dev_info->operating_system, dev_info->discriminant,
user_id);
- DB_ACTION(sqlite3_bind_text(stmt, 1, dev_info->device_id, -1, SQLITE_TRANSIENT));
- DB_ACTION(sqlite3_bind_int(stmt, 2, dev_info->type));
- DB_ACTION(sqlite3_bind_text(stmt, 3, dev_info->mac, -1, SQLITE_TRANSIENT));
- DB_ACTION(sqlite3_bind_text(stmt, 4, dev_info->ipv4_addr, -1, SQLITE_TRANSIENT));
- DB_ACTION(sqlite3_bind_int64(stmt, 5, timestamp));
- DB_ACTION(sqlite3_bind_int(stmt, 6, presence_state));
- DB_ACTION(sqlite3_bind_int(stmt, 7, dev_info->operating_system));
- DB_ACTION(sqlite3_bind_int(stmt, 8, user_id));
- DB_ACTION(sqlite3_bind_int(stmt, 9, dev_info->discriminant));
- DB_ACTION(sqlite3_bind_int(stmt, 10, max_device_number + 1));
+ DB_ACTION(sqlite3_bind_text(stmt, 1, dev_info->device_id, -1, SQLITE_TRANSIENT),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 2, dev_info->type),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 3, dev_info->mac, -1, SQLITE_TRANSIENT),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 4, dev_info->ipv4_addr, -1, SQLITE_TRANSIENT),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int64(stmt, 5, timestamp),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 6, presence_state),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 7, dev_info->operating_system),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 8, user_id),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 9, dev_info->discriminant),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 10, max_device_number + 1),
+ error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to insert device info: %s",
goto handle_error;
}
- UAM_DBG("Device info inserted device_id [%s] user id [%d]", dev_info->device_id, user_id);
+ UAM_DBG("Device info inserted device_id [%s] user id [%d]",
+ dev_info->device_id, user_id);
max_device_number = max_device_number + 1;
handle_error:
return error_code;
}
-int _ua_device_db_delete_device_info(const char *device_id, int tech_type, const char *address)
+int _ua_device_db_delete_device_info(const char *device_id, int tech_type,
+ const char *address)
{
FUNC_ENTRY;
int error_code = UAM_ERROR_NONE;
UAM_INFO("DeviceId: %s", device_id);
- DB_ACTION(sqlite3_bind_text(stmt, 1, device_id, -1, SQLITE_STATIC));
- DB_ACTION(sqlite3_bind_int(stmt, 2, tech_type));
- DB_ACTION(sqlite3_bind_text(stmt, 3, address, -1, SQLITE_STATIC));
+ DB_ACTION(sqlite3_bind_text(stmt, 1, device_id, -1, SQLITE_STATIC),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 2, tech_type),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 3, address, -1, SQLITE_STATIC),
+ error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to delete device info %s",
UAM_INFO("UserId: %s", device_id);
- DB_ACTION(sqlite3_bind_text(stmt, 1, device_id, -1, SQLITE_STATIC));
- DB_ACTION(sqlite3_bind_int(stmt, 2, tech_type));
- DB_ACTION(sqlite3_bind_text(stmt, 3, address, -1, SQLITE_STATIC));
+ DB_ACTION(sqlite3_bind_text(stmt, 1, device_id, -1, SQLITE_STATIC),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 2, tech_type),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 3, address, -1, SQLITE_STATIC),
+ error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to select device info %s",
} else {
UAM_DBG("User info found");
info = g_new0(db_device_info_t, 1);
- g_strlcpy(info->dev_info.device_id, (char *)sqlite3_column_text(stmt, 0), UAM_DEVICE_ID_MAX_STRING_LEN);
+ g_strlcpy(info->dev_info.device_id, (char *)sqlite3_column_text(stmt, 0),
+ UAM_DEVICE_ID_MAX_STRING_LEN);
info->dev_info.type = sqlite3_column_int(stmt, 1);
- g_strlcpy(info->dev_info.mac, (char *)sqlite3_column_text(stmt, 2), UAM_MAC_ADDRESS_STRING_LEN);
- g_strlcpy(info->dev_info.ipv4_addr, (char *)sqlite3_column_text(stmt, 3), UAM_IP_ADDRESS_MAX_STRING_LEN);
+ g_strlcpy(info->dev_info.mac, (char *)sqlite3_column_text(stmt, 2),
+ UAM_MAC_ADDRESS_STRING_LEN);
+ g_strlcpy(info->dev_info.ipv4_addr, (char *)sqlite3_column_text(stmt, 3),
+ UAM_IP_ADDRESS_MAX_STRING_LEN);
info->timestamp = sqlite3_column_int64(stmt, 4);
info->presence_state = sqlite3_column_int(stmt, 5);
info->dev_info.operating_system = sqlite3_column_int(stmt, 6);
info->user_id = sqlite3_column_int(stmt, 7);
info->discriminant = sqlite3_column_int(stmt, 8);
- UAM_INFO("%s-%d-%s-%s-%ld-%d-%d-%d-%d", info->dev_info.device_id, info->dev_info.type, info->dev_info.mac,
- info->dev_info.ipv4_addr, info->timestamp, info->presence_state,
- info->dev_info.operating_system, info->user_id,
- info->discriminant);
+ UAM_INFO("%s-%d-%s-%s-%ld-%d-%d-%d-%d",
+ info->dev_info.device_id,
+ info->dev_info.type,
+ info->dev_info.mac,
+ info->dev_info.ipv4_addr,
+ info->timestamp,
+ info->presence_state,
+ info->dev_info.operating_system,
+ info->user_id,
+ info->discriminant);
}
handle_error:
return error_code;
}
-int _uam_db_get_device_number(const char *device_id, int tech_type, const char *address, int *device_number)
+int _uam_db_get_device_number(const char *device_id, int tech_type,
+ const char *address, int *device_number)
{
FUNC_ENTRY;
int rc;
UAM_INFO("UserId: %s", device_id);
- DB_ACTION(sqlite3_bind_text(stmt, 1, device_id, -1, SQLITE_STATIC));
- DB_ACTION(sqlite3_bind_int(stmt, 2, tech_type));
- DB_ACTION(sqlite3_bind_text(stmt, 3, address, -1, SQLITE_STATIC));
+ DB_ACTION(sqlite3_bind_text(stmt, 1, device_id, -1, SQLITE_STATIC),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 2, tech_type),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 3, address, -1, SQLITE_STATIC),
+ error_code, handle_error);
do {
rc = sqlite3_step(stmt);
break;
case SQLITE_ROW:
info = g_new0(db_device_info_t, 1);
- g_strlcpy(info->dev_info.device_id, (char *)sqlite3_column_text(stmt, 0), UAM_DEVICE_ID_MAX_STRING_LEN);
+ g_strlcpy(info->dev_info.device_id, (char *)sqlite3_column_text(stmt, 0),
+ UAM_DEVICE_ID_MAX_STRING_LEN);
info->dev_info.type = sqlite3_column_int(stmt, 1);
- g_strlcpy(info->dev_info.mac, (char *)sqlite3_column_text(stmt, 2), UAM_MAC_ADDRESS_STRING_LEN);
- g_strlcpy(info->dev_info.ipv4_addr, (char *)sqlite3_column_text(stmt, 3), UAM_IP_ADDRESS_MAX_STRING_LEN);
+ g_strlcpy(info->dev_info.mac, (char *)sqlite3_column_text(stmt, 2),
+ UAM_MAC_ADDRESS_STRING_LEN);
+ g_strlcpy(info->dev_info.ipv4_addr, (char *)sqlite3_column_text(stmt, 3),
+ UAM_IP_ADDRESS_MAX_STRING_LEN);
info->timestamp = sqlite3_column_int64(stmt, 4);
info->presence_state = sqlite3_column_int(stmt, 5);
info->dev_info.operating_system = sqlite3_column_int(stmt, 6);
info->user_id = sqlite3_column_int(stmt, 7);
info->discriminant = sqlite3_column_int(stmt, 8);
- UAM_INFO("%s-%d-%s-%s-%ld-%d-%d-%d-%d", info->dev_info.device_id, info->dev_info.type, info->dev_info.mac,
- info->dev_info.ipv4_addr, info->timestamp, info->presence_state,
- info->dev_info.operating_system,
- info->user_id, info->discriminant);
+ UAM_INFO("%s-%d-%s-%s-%ld-%d-%d-%d-%d",
+ info->dev_info.device_id,
+ info->dev_info.type,
+ info->dev_info.mac,
+ info->dev_info.ipv4_addr,
+ info->timestamp,
+ info->presence_state,
+ info->dev_info.operating_system,
+ info->user_id,
+ info->discriminant);
device_list = g_slist_append(device_list, info);
break;
#include "ua-manager-database.h"
#define SELECT_SERVICE "SELECT S.service_number, S.service_name, S.cycle " \
- "FROM device_services as D JOIN services as S USING(service_number) where D.device_number = ?"
+ "FROM device_services as D JOIN services as S USING(service_number) " \
+ "where D.device_number = ?"
#define INSERT_DEVICE_SERVICE "insert into device_services " \
"(device_number, service_number) values (?, ?)"
#define DELETE_ALL_DEVICE_SERVICES "delete from device_services "
+
#define DELETE_DEVICE_SERVICE "delete from device_services " \
"WHERE device_number = ? and service_number = ?"
+
#define DELETE_SERVICE "delete from device_services " \
"WHERE service_number = ?"
-#ifndef DATABASE_FULL_PATH
-#define DATABASE_FULL_PATH "/opt/usr/dbspace/.ua-manager-data.db"
-#endif
-
-#define SQLITE_BUSY_TIMEOUT 500000
-
-static void __ua_device_service_finalize_delete(void);
-
-#define EXEC(error_code, command) do { \
- if (error_code != command) { \
- FUNC_EXIT; \
- goto handle_error; \
- } \
-} while (0)
-
-#define PREPARE_DELETE(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- __ua_device_service_finalize_delete(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-
-static void __ua_device_service_finalize_select(void);
-
-#define PREPARE_SELECT(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- __ua_device_service_finalize_select(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-
-static void __ua_device_service_finalize_update(void);
-
-#define PREPARE_UPDATE(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- __ua_device_service_finalize_update(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-
-static void __ua_device_service_finalize_insert(void);
-
-#define PREPARE_INSERT(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- __ua_device_service_finalize_insert(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-
-#define FINALIZE(stm) do { \
- if (stm) { \
- sqlite3_finalize(stm); \
- stm = NULL; \
- } \
-} while (0)
-
-#define DB_ACTION(command) do { \
- if ((command) != SQLITE_OK) { \
- error_code = UAM_ERROR_DB_FAILED; \
- FUNC_EXIT; \
- goto handle_error; \
- } \
-} while (0)
-
/* DELETE statements */
static sqlite3_stmt *delete_all_device_services;
static sqlite3_stmt *delete_service;
static sqlite3_stmt *insert_device_service;
extern sqlite3 *database;
+static void __ua_device_service_finalize_delete(void)
+{
+ FUNC_ENTRY;
+
+ FINALIZE(delete_all_device_services);
+ FINALIZE(delete_service);
+ FINALIZE(delete_device_service);
+
+ FUNC_EXIT;
+}
+
+static void __ua_device_service_finalize_select(void)
+{
+ FUNC_ENTRY;
+
+ FINALIZE(select_service);
+
+ FUNC_EXIT;
+}
+
+static void __ua_device_service_finalize_insert(void)
+{
+ FUNC_ENTRY;
+
+ FINALIZE(insert_device_service);
+
+ FUNC_EXIT;
+}
+
+static void __ua_device_service_finalize_update(void)
+{
+ FUNC_ENTRY;
+
+// TO-DO
+
+ FUNC_EXIT;
+}
+
+
static int __ua_device_service_prepare_delete(sqlite3 *db)
{
FUNC_ENTRY;
return SQLITE_OK;
}
- PREPARE_DELETE(delete_all_device_services, DELETE_ALL_DEVICE_SERVICES);
- PREPARE_DELETE(delete_service, DELETE_SERVICE);
- PREPARE_DELETE(delete_device_service, DELETE_DEVICE_SERVICE);
+ PREPARE_DELETE(rc, db, delete_all_device_services,
+ DELETE_ALL_DEVICE_SERVICES, __ua_device_service_finalize_delete);
+ PREPARE_DELETE(rc, db, delete_service,
+ DELETE_SERVICE, __ua_device_service_finalize_delete);
+ PREPARE_DELETE(rc, db, delete_device_service,
+ DELETE_DEVICE_SERVICE, __ua_device_service_finalize_delete);
initialized = 1;
FUNC_EXIT;
return SQLITE_OK;
}
- PREPARE_SELECT(select_service, SELECT_SERVICE);
+ PREPARE_SELECT(rc, db, select_service,
+ SELECT_SERVICE, __ua_device_service_finalize_select);
initialized = 1;
FUNC_EXIT;
return SQLITE_OK;
}
- PREPARE_INSERT(insert_device_service, INSERT_DEVICE_SERVICE);
+ PREPARE_INSERT(rc, db, insert_device_service,
+ INSERT_DEVICE_SERVICE, __ua_device_service_finalize_insert);
initialized = 1;
FUNC_EXIT;
return UAM_ERROR_DB_FAILED;
}
- DB_ACTION(__ua_device_service_prepare_delete(db));
- DB_ACTION(__ua_device_service_prepare_select(db));
- DB_ACTION(__ua_device_service_prepare_update(db));
- DB_ACTION(__ua_device_service_prepare_insert(db));
+ DB_ACTION(__ua_device_service_prepare_delete(db), error_code, handle_error);
+ DB_ACTION(__ua_device_service_prepare_select(db), error_code, handle_error);
+ DB_ACTION(__ua_device_service_prepare_update(db), error_code, handle_error);
+ DB_ACTION(__ua_device_service_prepare_insert(db), error_code, handle_error);
handle_error:
return error_code;
}
-static void __ua_device_service_finalize_delete(void)
-{
- FUNC_ENTRY;
-
- FINALIZE(delete_all_device_services);
- FINALIZE(delete_service);
- FINALIZE(delete_device_service);
-
- FUNC_EXIT;
-}
-
-static void __ua_device_service_finalize_select(void)
-{
- FUNC_ENTRY;
-
- FINALIZE(select_service);
-
- FUNC_EXIT;
-}
-
-static void __ua_device_service_finalize_insert(void)
-{
- FUNC_ENTRY;
-
- FINALIZE(insert_device_service);
-
- FUNC_EXIT;
-}
-
-static void __ua_device_service_finalize_update(void)
-{
- FUNC_ENTRY;
-
-// TO-DO
-
- FUNC_EXIT;
-}
-
static void __ua_device_service_table_devicesinfo_finalize(void)
{
FUNC_ENTRY;
{
FUNC_ENTRY;
- EXEC(UAM_ERROR_NONE, __ua_device_service_table_deviceservicesinfo_prepare(database));
+ EXEC(UAM_ERROR_NONE, __ua_device_service_table_deviceservicesinfo_prepare(database),
+ handle_error);
FUNC_EXIT;
return UAM_ERROR_NONE;
UAM_INFO("%d-%d", device_number, service_number);
- DB_ACTION(sqlite3_bind_int(stmt, 1, device_number));
- DB_ACTION(sqlite3_bind_int(stmt, 2, service_number));
+ DB_ACTION(sqlite3_bind_int(stmt, 1, device_number), error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 2, service_number), error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to insert device-service info: %s",
const char *address, const char *service_name, int cycle)
{
FUNC_ENTRY;
+ int ret = UAM_ERROR_NONE;
db_service_info_t info;
int service_number = 0;
int error_code = UAM_ERROR_NONE;
UAM_INFO("%s-%d-%s-%s-%d", device_id, tech_type, address, service_name, cycle);
int device_number = 0;
- if (_uam_db_get_device_number(device_id, tech_type, address, &device_number) != UAM_ERROR_NONE)
+ ret = _uam_db_get_device_number(device_id, tech_type, address, &device_number);
+ if (UAM_ERROR_NONE != ret)
goto handle_error;
- if (_uam_db_get_service_info(service_name, &info) != UAM_ERROR_NONE) {
- if (_uam_db_insert_service_info(&service_number, service_name, cycle) != UAM_ERROR_NONE)
+ ret = _uam_db_get_service_info(service_name, &info);
+ if (UAM_ERROR_NONE != ret) {
+ ret = _uam_db_insert_service_info(&service_number, service_name, cycle);
+ if (UAM_ERROR_NONE != ret)
goto handle_error;
} else
service_number = info.service_number;
UAM_INFO("%d-%d", device_number, service_number);
- if (_uam_db_insert_service(device_number, service_number) != UAM_ERROR_NONE)
+ ret = _uam_db_insert_service(device_number, service_number);
+ if (UAM_ERROR_NONE != ret)
goto handle_error;
UAM_DBG("Device-service info inserted [%d] [%d]", device_number, service_number);
UAM_INFO("Service Number: %d", service_number);
- DB_ACTION(sqlite3_bind_int(stmt, 1, service_number));
+ DB_ACTION(sqlite3_bind_int(stmt, 1, service_number), error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to delete device-service info %s",
UAM_INFO("Device Number: %d Service Number: %d", device_number, service_number);
- DB_ACTION(sqlite3_bind_int(stmt, 1, device_number));
- DB_ACTION(sqlite3_bind_int(stmt, 2, service_number));
+ DB_ACTION(sqlite3_bind_int(stmt, 1, device_number), error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 2, service_number), error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to delete device-service info %s",
{
FUNC_ENTRY;
db_service_info_t info;
+ int ret = UAM_ERROR_NONE;
int service_number = 0;
int error_code = UAM_ERROR_NONE;
UAM_INFO("%s", service_name);
- if (_uam_db_get_service_info(service_name, &info) != UAM_ERROR_NONE)
- goto handle_error;
+ ret = _uam_db_get_service_info(service_name, &info);
+ if (UAM_ERROR_NONE != ret)
+ goto handle_error;
service_number = info.service_number;
UAM_INFO("%d", service_number);
- if (_uam_db_delete_service_number(service_number) != UAM_ERROR_NONE)
+ ret = _uam_db_delete_service_number(service_number);
+ if (UAM_ERROR_NONE != ret)
goto handle_error;
UAM_DBG("Service info deleted [%d]", service_number);
{
FUNC_ENTRY;
db_service_info_t info;
+ int ret = UAM_ERROR_NONE;
int service_number = 0;
int device_number = 0;
int error_code = UAM_ERROR_NONE;
UAM_INFO("%s-%d-%s-%s", device_id, tech_type, address, service_name);
- if (_uam_db_get_device_number(device_id, tech_type, address, &device_number) != UAM_ERROR_NONE)
+ ret = _uam_db_get_device_number(device_id, tech_type, address, &device_number);
+ if (UAM_ERROR_NONE != ret)
goto handle_error;
- if (_uam_db_get_service_info(service_name, &info) != UAM_ERROR_NONE)
+ ret = _uam_db_get_service_info(service_name, &info);
+ if (UAM_ERROR_NONE != ret)
goto handle_error;
service_number = info.service_number;
UAM_INFO("%d-%d", device_number, service_number);
- if (_uam_db_delete_device_service_number(device_number, service_number) != UAM_ERROR_NONE)
+ ret = _uam_db_delete_device_service_number(device_number, service_number);
+ if (UAM_ERROR_NONE != ret)
goto handle_error;
UAM_DBG("Device-service info deleted [%d] [%d]", device_number, service_number);
case SQLITE_ROW:
info = g_new0(db_service_info_t, 1);
info->service_number = sqlite3_column_int(stmt, 0);
- g_strlcpy(info->service_name, (char *)sqlite3_column_text(stmt, 1), UAM_SERVICE_MAX_STRING_LEN);
+ g_strlcpy(info->service_name, (char *)sqlite3_column_text(stmt, 1),
+ UAM_SERVICE_MAX_STRING_LEN);
info->cycle = sqlite3_column_int(stmt, 2);
UAM_INFO("%d-%s-%d", info->service_number, info->service_name, info->cycle);
return service_list;
}
-GSList *_uam_db_get_device_services(const char *device_id, int tech_type, const char *address)
+GSList *_uam_db_get_device_services(const char *device_id, int tech_type,
+ const char *address)
{
FUNC_ENTRY;
+ int ret = UAM_ERROR_NONE;
+ int device_number = 0;
UAM_INFO("%s-%d-%s", device_id, tech_type, address);
GSList *service_list = NULL;
- int device_number = 0;
- if (_uam_db_get_device_number(device_id, tech_type, address, &device_number) != UAM_ERROR_NONE)
+ ret = _uam_db_get_device_number(device_id, tech_type, address, &device_number);
+ if (UAM_ERROR_NONE != ret)
goto handle_error;
service_list = _uam_db_get_service(device_number);
#define SELECT_ALL_SERVICES "SELECT service_number, service_name, " \
"cycle FROM services"
+
#define SELECT_SERVICE "SELECT service_number, service_name, cycle " \
"FROM services where service_name = ?"
+
#define SELECT_MAX_SERVICE_NUMBER "SELECT MAX(service_number) FROM services"
-#define INSERT_SERVICE "insert into services (service_number, service_name, cycle) values (?, ?, ?)"
+#define INSERT_SERVICE "insert into services (service_number, service_name, cycle) " \
+ "values (?, ?, ?)"
#define UPDATE_CYCLE "UPDATE services SET cycle = ? WHERE service_name = ?"
#define DELETE_ALL_SERVICES "delete from services"
-#define DELETE_SERVICE_INFO "delete from services WHERE service_name = ?"
-#ifndef DATABASE_FULL_PATH
-#define DATABASE_FULL_PATH "/opt/usr/dbspace/.ua-manager-data.db"
-#endif
-
-#define SQLITE_BUSY_TIMEOUT 500000
-
-static void __ua_service_finalize_delete(void);
-
-#define EXEC(error_code, command) do { \
- if (error_code != command) { \
- FUNC_EXIT; \
- goto handle_error; \
- } \
-} while (0)
-
-#define PREPARE_DELETE(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- __ua_service_finalize_delete(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-
-static void __ua_service_finalize_select(void);
-
-#define PREPARE_SELECT(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- __ua_service_finalize_select(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-
-static void _ua_service_finalize_update(void);
-
-#define PREPARE_UPDATE(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- _ua_service_finalize_update(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-
-static void __ua_service_finalize_insert(void);
-
-#define PREPARE_INSERT(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- __ua_service_finalize_insert(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-
-#define FINALIZE(stm) do { \
- if (stm) { \
- sqlite3_finalize(stm); \
- stm = NULL; \
- } \
-} while (0)
-
-#define DB_ACTION(command) do { \
- if ((command) != SQLITE_OK) { \
- error_code = UAM_ERROR_DB_FAILED; \
- FUNC_EXIT; \
- goto handle_error; \
- } \
-} while (0)
+#define DELETE_SERVICE_INFO "delete from services WHERE service_name = ?"
/* DELETE statements */
static sqlite3_stmt *delete_all_services;
extern sqlite3 *database;
static int max_service_number;
+static void __ua_service_finalize_delete(void)
+{
+ FUNC_ENTRY;
+
+ FINALIZE(delete_all_services);
+ FINALIZE(delete_service_info);
+
+ FUNC_EXIT;
+}
+
+static void __ua_service_finalize_select(void)
+{
+ FUNC_ENTRY;
+
+ FINALIZE(select_all_services);
+ FINALIZE(select_service);
+ FINALIZE(select_max_service_number);
+
+ FUNC_EXIT;
+}
+
+static void __ua_service_finalize_insert(void)
+{
+ FUNC_ENTRY;
+
+ FINALIZE(insert_service_info);
+
+ FUNC_EXIT;
+}
+
+static void __ua_service_finalize_update(void)
+{
+ FUNC_ENTRY;
+
+ FINALIZE(update_cycle);
+
+ FUNC_EXIT;
+}
+
static int __ua_service_prepare_delete(sqlite3 *db)
{
FUNC_ENTRY;
return SQLITE_OK;
}
- PREPARE_DELETE(delete_all_services, DELETE_ALL_SERVICES);
- PREPARE_DELETE(delete_service_info, DELETE_SERVICE_INFO);
+ PREPARE_DELETE(rc, db, delete_all_services,
+ DELETE_ALL_SERVICES, __ua_service_finalize_delete);
+ PREPARE_DELETE(rc, db, delete_service_info,
+ DELETE_SERVICE_INFO, __ua_service_finalize_delete);
initialized = 1;
FUNC_EXIT;
return SQLITE_OK;
}
- PREPARE_SELECT(select_all_services, SELECT_ALL_SERVICES);
- PREPARE_SELECT(select_service, SELECT_SERVICE);
- PREPARE_SELECT(select_max_service_number, SELECT_MAX_SERVICE_NUMBER);
+ PREPARE_SELECT(rc, db, select_all_services,
+ SELECT_ALL_SERVICES, __ua_service_finalize_select);
+ PREPARE_SELECT(rc, db, select_service,
+ SELECT_SERVICE, __ua_service_finalize_select);
+ PREPARE_SELECT(rc, db, select_max_service_number,
+ SELECT_MAX_SERVICE_NUMBER, __ua_service_finalize_select);
initialized = 1;
FUNC_EXIT;
return SQLITE_OK;
}
- PREPARE_UPDATE(update_cycle, UPDATE_CYCLE);
+ PREPARE_UPDATE(rc, db, update_cycle,
+ UPDATE_CYCLE, __ua_service_finalize_update);
initialized = 1;
FUNC_EXIT;
return SQLITE_OK;
}
- PREPARE_INSERT(insert_service_info, INSERT_SERVICE);
+ PREPARE_INSERT(rc, db, insert_service_info,
+ INSERT_SERVICE, __ua_service_finalize_insert);
initialized = 1;
FUNC_EXIT;
return UAM_ERROR_DB_FAILED;
}
- DB_ACTION(__ua_service_prepare_delete(db));
- DB_ACTION(__ua_service_prepare_select(db));
- DB_ACTION(__ua_service_prepare_update(db));
- DB_ACTION(__ua_service_prepare_insert(db));
+ DB_ACTION(__ua_service_prepare_delete(db), error_code, handle_error);
+ DB_ACTION(__ua_service_prepare_select(db), error_code, handle_error);
+ DB_ACTION(__ua_service_prepare_update(db), error_code, handle_error);
+ DB_ACTION(__ua_service_prepare_insert(db), error_code, handle_error);
handle_error:
return error_code;
}
-static void __ua_service_finalize_delete(void)
-{
- FUNC_ENTRY;
-
- FINALIZE(delete_all_services);
- FINALIZE(delete_service_info);
-
- FUNC_EXIT;
-}
-
-static void __ua_service_finalize_select(void)
-{
- FUNC_ENTRY;
-
- FINALIZE(select_all_services);
- FINALIZE(select_service);
- FINALIZE(select_max_service_number);
-
- FUNC_EXIT;
-}
-
-static void __ua_service_finalize_insert(void)
-{
- FUNC_ENTRY;
-
- FINALIZE(insert_service_info);
-
- FUNC_EXIT;
-}
-
-static void _ua_service_finalize_update(void)
-{
- FUNC_ENTRY;
-
- FINALIZE(update_cycle);
-
- FUNC_EXIT;
-}
-
static void __ua_service_table_servicesinfo_finalize(void)
{
FUNC_ENTRY;
{
FUNC_ENTRY;
- EXEC(UAM_ERROR_NONE, __ua_service_table_servicesinfo_prepare(database));
+ EXEC(UAM_ERROR_NONE, __ua_service_table_servicesinfo_prepare(database), handle_error);
if (_uam_db_get_max_service_number() != UAM_ERROR_NONE)
goto handle_error;
return UAM_ERROR_DB_FAILED;
}
-int _uam_db_insert_service_info(int *service_number, const char *service_name, int cycle)
+int _uam_db_insert_service_info(
+ int *service_number, const char *service_name, int cycle)
{
FUNC_ENTRY;
int error_code = UAM_ERROR_NONE;
UAM_INFO("%s-%d", service_name, cycle);
- DB_ACTION(sqlite3_bind_int(stmt, 1, max_service_number + 1));
- DB_ACTION(sqlite3_bind_text(stmt, 2, service_name, -1, SQLITE_TRANSIENT));
- DB_ACTION(sqlite3_bind_int(stmt, 3, cycle));
+ DB_ACTION(sqlite3_bind_int(stmt, 1, max_service_number + 1),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 2, service_name, -1, SQLITE_TRANSIENT),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_int(stmt, 3, cycle),
+ error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to insert service info: %s",
UAM_INFO("Service name: %s", service_name);
- DB_ACTION(sqlite3_bind_text(stmt, 1, service_name, -1, SQLITE_STATIC));
+ DB_ACTION(sqlite3_bind_text(stmt, 1, service_name, -1, SQLITE_STATIC),
+ error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to delete service info %s",
retv_if(NULL == service_name, UAM_ERROR_INVALID_PARAMETER);
- DB_ACTION(sqlite3_bind_int64(stmt, 1, cycle));
- DB_ACTION(sqlite3_bind_text(stmt, 2, service_name, -1, SQLITE_TRANSIENT));
+ DB_ACTION(sqlite3_bind_int64(stmt, 1, cycle),
+ error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 2, service_name, -1, SQLITE_TRANSIENT),
+ error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to update service timestamp: %s",
UAM_INFO("Service Name: %s", service_name);
- DB_ACTION(sqlite3_bind_text(stmt, 1, service_name, -1, SQLITE_STATIC));
+ DB_ACTION(sqlite3_bind_text(stmt, 1, service_name, -1, SQLITE_STATIC),
+ error_code, handle_error);
do {
rc = sqlite3_step(stmt);
case SQLITE_ROW:
UAM_DBG("Service info found");
info->service_number = sqlite3_column_int(stmt, 0);
- g_strlcpy(info->service_name, (char *)sqlite3_column_text(stmt, 1), UAM_SERVICE_MAX_STRING_LEN);
+ g_strlcpy(info->service_name, (char *)sqlite3_column_text(stmt, 1),
+ UAM_SERVICE_MAX_STRING_LEN);
info->cycle = sqlite3_column_int(stmt, 2);
UAM_INFO("%d-%s-%d", info->service_number, info->service_name, info->cycle);
case SQLITE_ROW:
info = g_new0(db_service_info_t, 1);
info->service_number = sqlite3_column_int(stmt, 0);
- g_strlcpy(info->service_name, (char *)sqlite3_column_text(stmt, 1), UAM_SERVICE_MAX_STRING_LEN);
+ g_strlcpy(info->service_name, (char *)sqlite3_column_text(stmt, 1),
+ UAM_SERVICE_MAX_STRING_LEN);
info->cycle = sqlite3_column_int(stmt, 2);
UAM_INFO("%d-%s-%d", info->service_number, info->service_name, info->cycle);
#define DELETE_USER_INFO "delete from userdata " \
"WHERE user_id = ? "
-#ifndef DATABASE_FULL_PATH
-#define DATABASE_FULL_PATH "/opt/usr/dbspace/.ua-manager-data.db"
-#endif
-
-#define SQLITE_BUSY_TIMEOUT 500000
-
-static void __ua_finalize_delete(void);
-
-#define EXEC(error_code, command) do { \
- if (error_code != command) { \
- FUNC_EXIT; \
- goto handle_error; \
- } \
-} while (0)
-
-#define PREPARE_DELETE(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- __ua_finalize_delete(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-
-static void __ua_finalize_select(void);
-
-#define PREPARE_SELECT(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- __ua_finalize_select(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-
-#if 0
-/* TODO: */
-static void _ua_finalize_update(void);
-
-#define PREPARE_UPDATE(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- _ua_finalize_update(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-#endif
-
-static void __ua_finalize_insert(void);
-
-#define PREPARE_INSERT(stm, query) do { \
- rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
- if (rc != SQLITE_OK) { \
- stm = NULL; \
- __ua_finalize_insert(); \
- UAM_ERR("Failed to prepare \"%s\" query" \
- , query); \
- return rc; \
- } \
-} while (0)
-
-#define FINALIZE(stm) do { \
- if (stm) { \
- sqlite3_finalize(stm); \
- stm = NULL; \
- } \
-} while (0)
-
-#define DB_ACTION(command) do { \
- if ((command) != SQLITE_OK) { \
- error_code = UAM_ERROR_DB_FAILED; \
- FUNC_EXIT; \
- goto handle_error; \
- } \
-} while (0)
-
/* DELETE statements */
static sqlite3_stmt *delete_all_users_data;
static sqlite3_stmt *delete_user_info;
/* INSERT statements */
static sqlite3_stmt *insert_user_info;
-sqlite3 *database;
+extern sqlite3 *database;
static int max_user_id;
+static void __ua_finalize_delete(void)
+{
+ FUNC_ENTRY;
+
+ FINALIZE(delete_all_users_data);
+ FINALIZE(delete_user_info);
+
+ FUNC_EXIT;
+}
+
+static void __ua_finalize_select(void)
+{
+ FUNC_ENTRY;
+
+ FINALIZE(select_all_users_data);
+ FINALIZE(select_user_data);
+ FINALIZE(select_max_user_id);
+
+ FUNC_EXIT;
+}
+
+static void __ua_finalize_insert(void)
+{
+ FUNC_ENTRY;
+
+ FINALIZE(insert_user_info);
+
+ FUNC_EXIT;
+}
+
+#if 0
+/* TODO */
+static void _ua_finalize_update(void)
+{
+ FUNC_ENTRY;
+
+
+ FUNC_EXIT;
+}
+#endif
+
static int __ua_prepare_delete(sqlite3 *db)
{
FUNC_ENTRY;
return SQLITE_OK;
}
- PREPARE_DELETE(delete_all_users_data, DELETE_ALL_USERS_DATA);
- PREPARE_DELETE(delete_user_info, DELETE_USER_INFO);
+ PREPARE_DELETE(rc, db, delete_all_users_data,
+ DELETE_ALL_USERS_DATA, __ua_finalize_delete);
+ PREPARE_DELETE(rc, db, delete_user_info,
+ DELETE_USER_INFO, __ua_finalize_delete);
initialized = 1;
FUNC_EXIT;
return SQLITE_OK;
}
- PREPARE_SELECT(select_all_users_data, SELECT_ALL_USERS_DATA);
- PREPARE_SELECT(select_user_data, SELECT_USER_DATA);
- PREPARE_SELECT(select_max_user_id, SELECT_MAX_USER_ID);
+ PREPARE_SELECT(rc, db, select_all_users_data,
+ SELECT_ALL_USERS_DATA, __ua_finalize_select);
+ PREPARE_SELECT(rc, db, select_user_data,
+ SELECT_USER_DATA, __ua_finalize_select);
+ PREPARE_SELECT(rc, db, select_max_user_id,
+ SELECT_MAX_USER_ID, __ua_finalize_select);
initialized = 1;
FUNC_EXIT;
return SQLITE_OK;
}
- PREPARE_INSERT(insert_user_info, INSERT_USER_INFO);
+ PREPARE_INSERT(rc, db, insert_user_info,
+ INSERT_USER_INFO, __ua_finalize_insert);
initialized = 1;
FUNC_EXIT;
return UAM_ERROR_DB_FAILED;
}
- DB_ACTION(__ua_prepare_delete(db));
- DB_ACTION(__ua_prepare_select(db));
- DB_ACTION(__ua_prepare_update(db));
- DB_ACTION(__ua_prepare_insert(db));
+ DB_ACTION(__ua_prepare_delete(db), error_code, handle_error);
+ DB_ACTION(__ua_prepare_select(db), error_code, handle_error);
+ DB_ACTION(__ua_prepare_update(db), error_code, handle_error);
+ DB_ACTION(__ua_prepare_insert(db), error_code, handle_error);
handle_error:
return error_code;
}
-static void __ua_finalize_delete(void)
-{
- FUNC_ENTRY;
-
- FINALIZE(delete_all_users_data);
- FINALIZE(delete_user_info);
-
- FUNC_EXIT;
-}
-
-static void __ua_finalize_select(void)
-{
- FUNC_ENTRY;
-
- FINALIZE(select_all_users_data);
- FINALIZE(select_user_data);
- FINALIZE(select_max_user_id);
-
- FUNC_EXIT;
-}
-
-static void __ua_finalize_insert(void)
-{
- FUNC_ENTRY;
-
- FINALIZE(insert_user_info);
-
- FUNC_EXIT;
-}
-
-#if 0
-/* TODO */
-static void _ua_finalize_update(void)
-{
- FUNC_ENTRY;
-
-
- FUNC_EXIT;
-}
-#endif
-
static void __ua_table_usersinfo_finalize(void)
{
FUNC_ENTRY;
if (UAM_ERROR_NONE != _ua_db_initialize_once())
goto handle_error;
- EXEC(UAM_ERROR_NONE, __ua_table_usersinfo_prepare(database));
+ EXEC(UAM_ERROR_NONE, __ua_table_usersinfo_prepare(database), handle_error);
if (_ua_device_db_initialize() != UAM_ERROR_NONE)
goto handle_error;
UAM_INFO("%s-%s", name, account);
- DB_ACTION(sqlite3_bind_int(stmt, 1, max_user_id + 1));
+ DB_ACTION(sqlite3_bind_int(stmt, 1, max_user_id + 1),
+ error_code, handle_error);
DB_ACTION(sqlite3_bind_text(stmt, 2, name ? name : "",
- -1, SQLITE_TRANSIENT));
- DB_ACTION(sqlite3_bind_text(stmt, 3, account, -1, SQLITE_TRANSIENT));
+ -1, SQLITE_TRANSIENT), error_code, handle_error);
+ DB_ACTION(sqlite3_bind_text(stmt, 3, account, -1, SQLITE_TRANSIENT),
+ error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to insert user info: %s",
UAM_INFO("UserId: %d", user_id);
- DB_ACTION(sqlite3_bind_int(stmt, 1, user_id));
+ DB_ACTION(sqlite3_bind_int(stmt, 1, user_id), error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to delete user info %s",
UAM_INFO("UserId: %d", user_id);
- DB_ACTION(sqlite3_bind_int(stmt, 1, user_id));
+ DB_ACTION(sqlite3_bind_int(stmt, 1, user_id), error_code, handle_error);
if (sqlite3_step(stmt) != SQLITE_DONE) {
UAM_ERR("Failed to select user info %s",
} else {
info = g_new0(db_user_info_t, 1);
info->user_id = sqlite3_column_int(stmt, 0);
- g_strlcpy(info->name, (char *)sqlite3_column_text(stmt, 1), UAM_USER_NAME_MAX_STRING_LEN);
- g_strlcpy(info->account, (char *)sqlite3_column_text(stmt, 2), UAM_USER_ACCOUNT_MAX_STRING_LEN);
+ g_strlcpy(info->name, (char *)sqlite3_column_text(stmt, 1),
+ UAM_USER_NAME_MAX_STRING_LEN);
+ g_strlcpy(info->account, (char *)sqlite3_column_text(stmt, 2),
+ UAM_USER_ACCOUNT_MAX_STRING_LEN);
UAM_INFO("%d-%s-%s", info->user_id, info->name,
info->account);
case SQLITE_ROW:
info = g_new0(db_user_info_t, 1);
info->user_id = sqlite3_column_int(stmt, 0);
- g_strlcpy(info->name, (char *)sqlite3_column_text(stmt, 1), UAM_USER_NAME_MAX_STRING_LEN);
- g_strlcpy(info->account, (char *)sqlite3_column_text(stmt, 2), UAM_USER_ACCOUNT_MAX_STRING_LEN);
+ g_strlcpy(info->name, (char *)sqlite3_column_text(stmt, 1),
+ UAM_USER_NAME_MAX_STRING_LEN);
+ g_strlcpy(info->account, (char *)sqlite3_column_text(stmt, 2),
+ UAM_USER_ACCOUNT_MAX_STRING_LEN);
UAM_INFO("%d-%s-%s", info->user_id, info->name,
info->account);
projects / platform / core / connectivity / ua-manager.git / commitdiff