GList *pairwise_list;
bool monitor_started;
+ bool first_search;
//sqlite3 db
sqlite3 *db;
#ifndef __MDGD_DB_H__
#define __MDGD_DB_H__
-#define MDGD_DB_FILE "/opt/usr/dbspace/.comp.db"
-#define MDGD_DB_TABLE "mdgd_group_information"
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define MDGD_DB_FILE "/opt/usr/dbspace/.mdgd.db"
+#define MDGD_DB_GROUP_TABLE "mdgd_group"
+#define MDGD_DB_DEVICE_TABLE "mdgd_device"
int mdgd_db_init();
int mdgd_db_deinit();
-int mdgd_db_insert(char *group_name, char *device_id);
-int mdgd_db_delete_group(char *group_name);
-int mdgd_db_delete_device(char *group_name, char *device_id);
+int mdgd_db_group_insert(const char *group_name);
+int mdgd_db_device_insert(const char *device_id, const char *group_name);
+int mdgd_db_group_delete(char *group_name);
+int mdgd_db_device_delete(char *device_id, char *group_name);
+
+#ifdef __cplusplus
+}
+#endif
#endif
int count; /**< Count of successful post method */
} mdgd_invited_device_t;
+typedef struct {
+ char *name; /**< Group name */
+ GList *device_list; /**< Remote device UUIDs. (char* type) */
+} mdgd_grp_t;
+
/* Called when daemon is start. */
int mdgd_group_initialize();
int mdgd_group_request_delete_group(char *uuid, char *group_name);
int mdgd_group_start_invited_device_monitor(int start);
+mdgd_mot_device_t *mdgd_group_check_device_in_mot_enb_dev_list(char *uuid);
#ifdef __cplusplus
}
return MDGD_ERROR_OUT_OF_MEMORY;
}
mdgd_ctx->mot_me = FALSE;
+ mdgd_ctx->first_search = TRUE;
return MDGD_ERROR_NONE;
}
return result;
}
-static int __create_table()
+static int __create_group_table()
{
int ret = 0;
int sql_ret;
return -1;
}
- sql = sqlite3_mprintf("CREATE TABLE %s(id INTEGER PRIMARY KEY, group_name TEXT, device_id TEXT);",
- MDGD_DB_TABLE);
+ sql = sqlite3_mprintf("CREATE TABLE %s(id INTEGER PRIMARY KEY, group_name TEXT);",
+ MDGD_DB_GROUP_TABLE);
+
+ if (sql != NULL) {
+ sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
+ if (sql_ret != SQLITE_OK) {
+ LOG_ERR("sqlite3_exec failed, %d, %s", sql_ret, error);
+ ret = -1;
+ sqlite3_free(error);
+ }
+ sqlite3_free(sql);
+ } else {
+ LOG_ERR("sql is NULL");
+ ret = -1;
+ }
+
+ return ret;
+}
+
+static int __create_device_table()
+{
+ int ret = 0;
+ int sql_ret;
+ char *sql = NULL;
+ char *error = NULL;
+
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+ if (mdgd_ctx->db == NULL) {
+ LOG_ERR("mdgd_ctx->db is NULL");
+ return -1;
+ }
+
+ sql = sqlite3_mprintf("CREATE TABLE %s(id INTEGER PRIMARY KEY, device_id TEXT, group_name TEXT);",
+ MDGD_DB_DEVICE_TABLE);
if (sql != NULL) {
sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
static void __prepare_table()
{
- if (__is_table_existing(MDGD_DB_TABLE) == false)
- __create_table();
+ if (__is_table_existing(MDGD_DB_GROUP_TABLE) == false)
+ __create_group_table();
+
+ if (__is_table_existing(MDGD_DB_DEVICE_TABLE) == false)
+ __create_device_table();
}
static int __check_integrity()
ret = sqlite3_step(stmt);
if (ret == SQLITE_ROW) {
const char *ret_val = (const char *)sqlite3_column_text(stmt, 0);
- LOG_ERR("ret_val: %s", ret_val);
if (ret_val && !strncmp(ret_val, "ok", strlen("ok"))) {
result = 0;
} else {
__prepare_table();
}
- if (mdgd_ctx->db != NULL) {
- //iot activity per each column
- LOG_ERR("comp db init");
- //mdgd_group_create(group_name);
+ if (mdgd_ctx->db == NULL) {
+ LOG_ERR("DB is NULL");
+ goto ERR;
}
return ret;
return ret;
}
-int mdgd_db_insert(char *group_name, char *device_id)
+int mdgd_db_group_insert(const char *group_name)
{
int ret = 0;
int sql_ret;
return -1;
}
- sql = sqlite3_mprintf("INSERT INTO %s (group_name, device_id) values(%Q, %Q);",
- MDGD_DB_TABLE,
- group_name,
- device_id);
+ sql = sqlite3_mprintf("INSERT INTO %s (group_name) values(%Q);",
+ MDGD_DB_GROUP_TABLE,
+ group_name);
+
+ if (sql != NULL) {
+ sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
+ if (sql_ret != SQLITE_OK) {
+ LOG_ERR("sqlite3_exec failed, %d, %s", sql_ret, error);
+ ret = -1;
+ sqlite3_free(error);
+ }
+ sqlite3_free(sql);
+ } else {
+ LOG_ERR("sql is NULL");
+ ret = -1;
+ }
+
+ return ret;
+}
+
+int mdgd_db_device_insert(const char *device_id, const char *group_name)
+{
+ int ret = 0;
+ int sql_ret;
+ char *sql = NULL;
+ char *error = NULL;
+
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+ if (mdgd_ctx->db == NULL) {
+ LOG_ERR("mtp_ctx->db is NULL");
+ return -1;
+ }
+
+ sql = sqlite3_mprintf("INSERT INTO %s (device_id, group_name) values(%Q, %Q);",
+ MDGD_DB_DEVICE_TABLE,
+ device_id,
+ group_name);
if (sql != NULL) {
sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
return ret;
}
-int mdgd_db_delete_group(char *group_name)
+int mdgd_db_group_delete(char *group_name)
{
int ret = 0;
int sql_ret;
}
sql = sqlite3_mprintf("DELETE FROM %s WHERE group_name=%Q",
- MDGD_DB_TABLE,
+ MDGD_DB_GROUP_TABLE,
group_name);
if (sql != NULL) {
return ret;
}
-int mdgd_db_delete_device(char *group_name, char *device_id)
+int mdgd_db_device_delete(char *device_id, char *group_name)
{
int ret = 0;
int sql_ret;
}
sql = sqlite3_mprintf("DELETE FROM %s WHERE group_name=%Q and device_id=%Q",
- MDGD_DB_TABLE,
+ MDGD_DB_DEVICE_TABLE,
group_name,
device_id);
LOG_DEBUG("group create called using dbus successful");
result = mdgd_group_create(group_name);
+ if (result == 0)
+ mdgd_db_group_insert(group_name);
group_complete_create(group, invocation, result);
LOG_DEBUG("group invite called using dbus successful");
result = mdgd_group_invite(group_name, uuid, pin);
+ if (result == 0)
+ mdgd_db_device_insert(uuid, group_name);
/* Now, for the sake of convenience, we change 'group_complete_invite' to 'group_complete_device_invite'. */
#if 0
/* Called when daemon is start. */
int mdgd_group_initialize()
{
- //Initialize memory of context
+ int sql_ret = SQLITE_OK;
+ char *sql = NULL;
+ sqlite3_stmt *stmt = NULL;
+
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
//1. group creation
- //db select
+ sql = sqlite3_mprintf("SELECT group_name FROM %s;", MDGD_DB_GROUP_TABLE);
+ if (sql != NULL) {
+ sql_ret = sqlite3_prepare_v2(mdgd_ctx->db, sql, strlen(sql), &stmt, NULL);
+ if (sql_ret != SQLITE_OK) {
+ LOG_ERR("Error: %s", sqlite3_errmsg(mdgd_ctx->db));
+ sqlite3_free(sql);
+ return MDGD_ERROR_UNKNOWN;
+ }
+
+ do {
+ sql_ret = sqlite3_step(stmt);
+ if (sql_ret != SQLITE_ROW) {
+ break;
+ }
+
+ char *group_name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
+
+ mdgd_group_create(group_name);
+ } while (sql_ret != SQLITE_DONE);
+
+ sqlite3_finalize(stmt);
+ sqlite3_free(sql);
+ }
+
//2. device creation
- //db select by group
+ mdgd_group_find_mot_enabled_devices(2);
return MDGD_ERROR_NONE;
}
-typedef struct {
- char *name; /**< Group name */
- GList *device_list; /**< Remote device UUIDs. (char* type) */
-} mdgd_grp_t;
-
void __print_foreach_device(gpointer data, gpointer user_data)
{
char *uuid = (char *)data;
mdgd_ctx->grp_list = g_list_append(mdgd_ctx->grp_list, grp);
- mdgd_group_add_device_in_group(name, mdgd_ctx->device_uuid);
mdgd_resource_print_list();
__print_groups_information();
}
}
-static mdgd_mot_device_t *_check_device_in_mot_enb_dev_list(char *uuid)
+mdgd_mot_device_t *mdgd_group_check_device_in_mot_enb_dev_list(char *uuid)
{
mdgd_mot_device_t *device;
GList *iter;
if (is_exist == FALSE) {
mdgd_mot_device_t *temp;
- temp = _check_device_in_mot_enb_dev_list(device->uuid);
+ temp = mdgd_group_check_device_in_mot_enb_dev_list(device->uuid);
if (temp)
device->host = _addr2host(temp->addr, temp->secure_port);
}
group->device_list = g_list_append(group->device_list, strdup(uuid));
- mdgd_db_insert(group_name, uuid);
__print_groups_information();
return 0;
iter = g_list_next(iter);
}
- mdgd_db_delete_device(group_name, uuid);
+ mdgd_db_device_delete(uuid, group_name);
__print_groups_information();
return 0;
cmd->uuid = g_strdup(uuid);
cmd->arg1 = g_strdup(group_name);
- device = _check_device_in_mot_enb_dev_list(uuid);
+ device = mdgd_group_check_device_in_mot_enb_dev_list(uuid);
if (device) {
cmd->host = _addr2host(device->addr, device->secure_port);
ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 5, cmd);
cmd->arg2 = g_strdup(target_uuid);
cmd->arg3 = g_strdup(PIN);
- device = _check_device_in_mot_enb_dev_list(uuid);
+ device = mdgd_group_check_device_in_mot_enb_dev_list(uuid);
if (device) {
cmd->host = _addr2host(device->addr, device->secure_port);
ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 5, cmd);
cmd->arg1 = g_strdup(group_name);
cmd->arg2 = g_strdup(target_uuid);
- device = _check_device_in_mot_enb_dev_list(uuid);
+ device = mdgd_group_check_device_in_mot_enb_dev_list(uuid);
if (device) {
cmd->host = _addr2host(device->addr, device->secure_port);
ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 5, cmd);
cmd->uuid = g_strdup(uuid);
cmd->arg1 = g_strdup(group_name);
- device = _check_device_in_mot_enb_dev_list(uuid);
+ device = mdgd_group_check_device_in_mot_enb_dev_list(uuid);
if (device) {
cmd->host = _addr2host(device->addr, device->secure_port);
ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 5, cmd);
#include <mdgd_group.h>
#include <mdgd_gdbus_group.h>
#include <mdgd_mot_agent.h>
+#include <mdgd_db.h>
#include "OCProvisioningManager.hpp"
#include "OCPlatform.h"
if (rep.getValue("name", group_name)) {
LOG_DEBUG("group_name : %s", group_name.c_str());
result = mdgd_group_create(group_name.c_str());
+ if (result == 0)
+ mdgd_db_group_insert(group_name.c_str());
arg = (unsigned char *) g_strdup(group_name.c_str());
arg_len = strlen(group_name.c_str());
}
result = mdgd_group_invite(group_name.c_str(),
uuid.c_str(), "12341234");
+ if (result == 0)
+ mdgd_db_device_insert(uuid.c_str(), group_name.c_str());
arg = (unsigned char *) g_strdup(uuid.c_str());
arg_len = strlen(uuid.c_str());
break;
return TRUE;
}
+void __invite_device(gpointer data, gpointer user_data)
+{
+ int sql_ret = SQLITE_OK;
+ char *sql = NULL;
+ sqlite3_stmt *stmt = NULL;
+
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+ mdgd_grp_t *grp = (mdgd_grp_t *)data;
+ LOG_DEBUG("Group name : %s", grp->name);
+
+ sql = sqlite3_mprintf("SELECT device_id FROM %s WHERE group_name=%Q;",
+ MDGD_DB_DEVICE_TABLE, grp->name);
+
+ if (sql != NULL) {
+ sql_ret = sqlite3_prepare_v2(mdgd_ctx->db, sql, strlen(sql), &stmt, NULL);
+ if (sql_ret != SQLITE_OK) {
+ LOG_ERR("Error: %s", sqlite3_errmsg(mdgd_ctx->db));
+ sqlite3_free(sql);
+ return;
+ }
+
+ do {
+ sql_ret = sqlite3_step(stmt);
+ if (sql_ret != SQLITE_ROW) {
+ break;
+ }
+
+ char *device_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
+ mdgd_mot_device_t *device = mdgd_group_check_device_in_mot_enb_dev_list(device_id);
+
+ if (device != NULL)
+ mdgd_group_add_device_in_group(grp->name, device_id);
+ } while (sql_ret != SQLITE_DONE);
+
+ sqlite3_finalize(stmt);
+ sqlite3_free(sql);
+ }
+}
+
static gboolean _timeout_cb(gpointer data)
{
int ret = MDGD_ERROR_NONE;
} else if (cmd->resource_type == MDGD_RESOURCE_TYPE_DEVICE) {
if (!strncmp(cmd->arg1, "disc_mot_enb_devs_done", strlen(cmd->arg1))) {
LOG_DEBUG("Device Find Done. notified");
+<<<<<<< HEAD
mdgd_group_notify_mot_enable_device_done();
notify_device_find_finish(ret);
+=======
+ if (mdgd_group_get_mot_device_count() > 0)
+ ret = 0;
+
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+ if (mdgd_ctx->first_search == true) {
+ if (ret == 0)
+ g_list_foreach(mdgd_ctx->grp_list, __invite_device, NULL);
+ mdgd_ctx->first_search = false;
+ } else {
+ mdgd_group_notify_mot_enable_device_done();
+ notify_device_find_finish(ret);
+ }
+>>>>>>> Add daemon recovery when daemon is reboot impl
} else {
LOG_DEBUG("MOT Device Find Done. notified");
mdgd_group_notify_mowned_device_find_done();
goto EXIT;
}
- //5. Make TX interface
-
- //example code
- //6. group mgr initialize
- ret = mdgd_group_initialize();
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("COMP group initialize failed : %s", mdgd_log_get_error_string(ret));
- goto EXIT;
- }
-
//7. operation mgr initialize
ret = agent_dbus_start();
if (ret != MDGD_ERROR_NONE) {
}
agent_enable();
+ //example code
+ //6. group mgr initialize
+ ret = mdgd_group_initialize();
+ if (ret != MDGD_ERROR_NONE) {
+ LOG_ERR("COMP group initialize failed : %s", mdgd_log_get_error_string(ret));
+ goto EXIT;
+ }
+
//8. g main loop run
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx, MDGD_ERROR_INVALID_PARAMETER);