#endif
#include <stdbool.h>
+#include <mdgd_typedef.h>
#define MDGD_DB_FILE "/opt/usr/dbspace/.mdgd.db"
#define MDGD_DB_GROUP_TABLE "mdgd_group"
int mdgd_db_init();
int mdgd_db_deinit();
int mdgd_db_group_insert(const char *group_name);
-int mdgd_db_device_insert(const char *group_name, const char *device_id);
+int mdgd_db_device_insert(const char *group_name, mdgd_device_t *device);
int mdgd_db_group_delete(char *group_name);
int mdgd_db_device_delete(char *group_name, char *device_id);
bool mdgd_db_check_device_exist(char *device_id);
bool mdgd_db_check_device_exist_in_group(char *group_name, char *device_id);
bool mdgd_db_check_group_exist(const char *group_name);
void mdgd_db_get_groups(char **groups, int *group_count);
-void mdgd_db_get_devices_in_group(char *group_name, char **devices, int *device_count);
+void mdgd_db_get_devices_in_group(char *group_name, mdgd_device_t **devices, int *device_count);
int mdgd_db_group_print();
int mdgd_db_device_print();
int mdgd_group_find(char *sender, int timeout);
int mdgd_group_find_device(char *sender, int timeout, bool is_invited);
-int mdgd_group_invite_device(char *sender, const char *group_name, const char *uuid, const char *pin);
+int mdgd_group_invite_device(char *sender, const char *group_name,
+ mdgd_device_t *device, const char *pin);
int mdgd_group_eject_device(char *sender, const char *group_name, const char *uuid);
int mdgd_group_regist_channel(char *sender, char *channel_id);
unsigned char *data, int len);
/* Group Request to remote */
-int mdgd_group_request_create_group(char *sender, char *uuid, char *addr, int port, char *group_name);
+int mdgd_group_request_create_group(char *sender, char *uuid, char *addr,int port, char *group_name);
int mdgd_group_request_invite(char *sender, char *uuid, char *addr, int port, char *group_name, char *target_uuid, char *PIN);
int mdgd_group_request_eject(char *sender, char *uuid, char *addr, int port, char *group_name, char *target_uuid);
int mdgd_group_request_channel_list(char *sender, char *uuid, char *addr, int port);
MDGD_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
MDGD_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */
MDGD_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */
- MDGD_ERROR_NO_DATA = TIZEN_ERROR_MDG | 0x01, /**< Data not exists */
- MDGD_ERROR_OPERATION_FAILED = TIZEN_ERROR_MDG | 0x02, /**< operation failed */
+ MDGD_ERROR_OPERATION_FAILED = TIZEN_ERROR_MDG | 0x01, /**< operation failed */
+ MDGD_ERROR_NO_DATA = TIZEN_ERROR_MDG | 0x02, /**< Data not exists */
MDGD_ERROR_ALREADY_REGISTERED = TIZEN_ERROR_MDG | 0x03, /**< Request already registered */
MDGD_ERROR_IN_PROGRESS = TIZEN_ERROR_MDG | 0x04,/**< operation is in progress */
MDGD_ERROR_COMM_ERROR = TIZEN_ERROR_MDG | 0x05, /**< communication error */
- MDGD_ERROR_PLUGIN_FAIL = TIZEN_ERROR_MDG | 0x08, /**< Plugin failed */
- MDGD_ERROR_ALREADY_IN_PROGRESS = TIZEN_ERROR_MDG | 0x09, /**< Already in progress */
- MDGD_ERROR_DB = TIZEN_ERROR_MDG | 0x0A, /**< DB Error */
- MDGD_ERROR_IOTIVITY = TIZEN_ERROR_MDG | 0x0B, /**< Iotivity Error */
- MDGD_ERROR_UNKNOWN = -999
-} mdgd_error_e;
+ MDGD_ERROR_PLUGIN_FAIL = TIZEN_ERROR_MDG | 0x06, /**< Plugin failed */
+ MDGD_ERROR_NOT_STARTED = TIZEN_ERROR_MDG | 0x07, /**< Service Not Started */
+ MDGD_ERROR_DB = TIZEN_ERROR_MDG | 0x08, /**< Internal DB error */
+} mdg_error_e;
-/**
- * @brief Resource type.
- *
- * @since_tizen 5.0
- */
typedef enum {
MDGD_RESOURCE_TYPE_GROUP = 0, /**< Group resource type */
MDGD_RESOURCE_TYPE_DEVICE, /**< Device resource type */
MDGD_RESOURCE_TYPE_MAX
} mdgd_resource_type_e;
-/**
- * @brief Group type.
- *
- * @since_tizen 5.0
- */
typedef enum {
MDGD_GROUP_TYPE_LOCAL = 1, /**< Local group type */
MDGD_GROUP_TYPE_REMOTE = 2, /**< Remote group type */
MDGD_DEVICE_TYPE_REMOTE = 2, /**< Remote group type */
} mdgd_device_type_e;
-/**
- * @brief The command type for request.
- *
- * @since_tizen 5.0
- */
typedef enum {
- MDGD_REQ_UNKNOWN_COMMAND = -1, /**< Unknown Command */
- MDGD_REQ_SEND_DATA = 0, /**< Send data */
- MDGD_REQ_CREATE_GROUP, /**< Create Group */
+ MDGD_REQ_CREATE_GROUP = 0, /**< Create Group */
MDGD_REQ_INVITE_DEVICE, /**< Invite Device */
MDGD_REQ_EJECT_DEVICE, /**< Eject Device */
MDGD_REQ_CHANNEL_LIST, /**< Channel List */
- MDGD_REQ_SEND_FILE,
+ MDGD_REQ_SEND_DATA, /**< Send data */
+ MDGD_REQ_SEND_FILE, /**< Send File */
} mdgd_request_type_e;
typedef enum {
MDGD_EVENT_SEND_DATA_FINISH,
MDGD_EVENT_REQ_CHANNEL_LIST_FINISH,
MDGD_EVENT_RECEIVE_DATA,
+ MDGD_EVENT_RECEIVE_FILE,
} mdgd_event_type_e;
typedef struct {
} mdgd_device_t;
typedef struct {
- char *device_id; /**< Device Id */
+ char *device_id;
char *channel_id;
} mdgd_channel_t;
GDBusConnection *connection;
} mdgd_conn_destroy_data;
-typedef struct _mdgd_command_t {
+typedef struct {
int tid; /**< Timer ID */
int resource_type; /**< OCF resource type */
mdgd_request_type_e command; /**< Comments set for group management */
void *user_data;
} mdgd_command_t;
-typedef struct _mdgd_rd_t {
+typedef struct {
mdgd_resource_type_e resource_type;
char *type;
char *uri_prefix;
#include <pmtypes.h>
#include <mdgd_log.h>
-#define LOCAL_IP 1 /**< Local IP */
-#define REMOTE_IP 2 /**< Remote IP */
-
-void mdgd_remove_ip_info(void);
-int mdgd_make_ip_info(void);
-int mdgd_is_local_ip(char *ipdata);
char *mdgd_addr2host(char *addr, int port, bool is_secure);
int mdgd_uuid_to_str(const OicUuid_t* uuid, char** strUuid);
void mdgd_clean_user_data(void *user_data);
GVariant *mdgd_create_variant_device(mdgd_device_t *device);
GVariant *mdgd_create_variant_channel(mdgd_channel_t *channel);
GVariant *mdgd_create_variant_data(mdgd_data_t *data);
+GVariant *mdgd_create_variant_device_list(char *group_name);
GVariant *mdgd_create_variant_dummy();
+mdgd_device_t *mdg_get_device_from_variant(GVariant *va);
#ifdef __cplusplus
</method>
<method name="InviteDevice">
<arg type="s" name="group_name" direction="in"/>
- <arg type="s" name="uuid" direction="in"/>
+ <arg type="a{sv}" name="device_info" direction="in"/>
<arg type="s" name="pin" direction="in" />
<arg type="i" name="result" direction="out"/>
</method>
<method name="GetLocalDevice">
<arg type="a{sv}" name="device_info" direction="out" />
</method>
- <method name="GetMemberDevices">
+ <method name="ForeachDevice">
<arg type="s" name="group_name" direction="in"/>
+ <arg type="i" name="result" direction="out" />
<arg type="aa{sv}" name="devices" direction="out" />
</method>
<method name="RegistChannel">
return -1;
}
- sql = sqlite3_mprintf("CREATE TABLE %s(id INTEGER PRIMARY KEY, group_name TEXT, device_id TEXT);",
+ sql = sqlite3_mprintf("CREATE TABLE %s(id INTEGER PRIMARY KEY, group_name TEXT, device_id TEXT, port INTEGER, addr TEXT, conn_type INTEGER, secure_port INTEGER, model_name TEXT, device_name TEXT, platform_ver TEXT, vendor_id TEXT, profile TEXT, is_invited INTEGER, type INTEGER);",
MDGD_DB_DEVICE_TABLE);
if (sql != NULL) {
return ret;
}
-int mdgd_db_device_insert(const char *group_name, const char *device_id)
+int mdgd_db_device_insert(const char *group_name, mdgd_device_t *device)
{
int ret = 0;
int sql_ret;
return -1;
}
- sql = sqlite3_mprintf("INSERT INTO %s (device_id, group_name) values(%Q, %Q);",
+ sql = sqlite3_mprintf("INSERT INTO %s (group_name, device_id, port, addr, conn_type, secure_port, model_name, device_name, platform_ver, vendor_id, profile, is_invited, type) values(%Q, %Q, %d, %Q, %d, %d, %Q, %Q, %Q, %Q, %Q, %d, %d);",
MDGD_DB_DEVICE_TABLE,
- device_id,
- group_name);
+ group_name,
+ device->device_id,
+ device->port,
+ device->addr,
+ device->conn_type,
+ device->secure_port,
+ device->model_name,
+ device->device_name,
+ device->platform_ver,
+ device->vendor_id,
+ device->profile,
+ device->is_invited,
+ device->type);
if (sql != NULL) {
sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
LOG_END();
}
-void mdgd_db_get_devices_in_group(char *group_name, char **devices, int *device_count)
+void mdgd_db_get_devices_in_group(char *group_name, mdgd_device_t **devices, int *device_count)
{
int ret, i = 0;
char *sql = NULL;
ret = sqlite3_prepare_v2(mdgd_ctx->db, sql, strlen(sql), &stmt, NULL);
if (ret == SQLITE_OK) {
- while (sqlite3_step(stmt) == SQLITE_ROW)
- devices[i++] = g_strdup(sqlite3_column_text(stmt, 2));
-
+ while (sqlite3_step(stmt) == SQLITE_ROW) {
+ devices[i] = g_new0(mdgd_device_t, 1);
+ devices[i]->device_id = g_strdup(sqlite3_column_text(stmt, 2));
+ devices[i]->port = sqlite3_column_int(stmt, 3);
+ devices[i]->addr = g_strdup(sqlite3_column_text(stmt, 4));
+ devices[i]->conn_type = sqlite3_column_int(stmt, 5);
+ devices[i]->secure_port = sqlite3_column_int(stmt, 6);
+ devices[i]->model_name = g_strdup(sqlite3_column_text(stmt, 7));
+ devices[i]->device_name = g_strdup(sqlite3_column_text(stmt, 8));
+ devices[i]->platform_ver = g_strdup(sqlite3_column_text(stmt, 9));
+ devices[i]->vendor_id = g_strdup(sqlite3_column_text(stmt, 10));
+ devices[i]->profile = g_strdup(sqlite3_column_text(stmt, 11));
+ devices[i]->is_invited = sqlite3_column_int(stmt,12);
+ devices[i]->type = sqlite3_column_int(stmt, 13);
+
+ i++;
+ }
sqlite3_finalize(stmt);
} else {
LOG_ERR("sqlite3_prepare_v2 failed, [%d:%s]", ret, sqlite3_errmsg(mdgd_ctx->db));
gboolean group_find(Group *group, GDBusMethodInvocation *invocation, gint timeout,
gpointer user_data)
{
- gint result = MDGD_ERROR_UNKNOWN;
+ gint result = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
gboolean group_delete(Group *group, GDBusMethodInvocation *invocation,
gchar *group_name, gpointer user_data)
{
- gint result = MDGD_ERROR_UNKNOWN;
+ gint result = MDGD_ERROR_NONE;
LOG_BEGIN();
gboolean group_find_device(Group *group, GDBusMethodInvocation *invocation,
gint timeout, gint is_invited, gpointer user_data)
{
- int result = MDGD_ERROR_UNKNOWN;
+ int result = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
}
gboolean group_invite_device(Group *group, GDBusMethodInvocation *invocation, gchar *group_name,
- gchar *uuid, gchar *pin, gpointer user_data)
+ GVariant *va, gchar *pin, gpointer user_data)
{
- gint result = MDGD_ERROR_UNKNOWN;
+ gint result = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
- result = mdgd_group_invite_device(sender, group_name, uuid, pin);
+ mdgd_device_t *device = mdgd_get_device_from_variant(va);
+
+ result = mdgd_group_invite_device(sender, group_name, device, pin);
+
group_complete_invite_device(group, invocation, result);
LOG_END();
gboolean group_eject_device(Group *group, GDBusMethodInvocation *invocation, gchar *group_name,
gchar *uuid, gpointer user_data)
{
- gint result = MDGD_ERROR_UNKNOWN;
+ gint result = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
return TRUE;
}
-gboolean group_get_member_device_list(Group *group,
- GDBusMethodInvocation *invocation, gpointer user_data)
+gboolean group_foreach_device(Group *group, GDBusMethodInvocation *invocation,
+ gchar *group_name, gpointer user_data)
{
- GVariant *device_data;
+ int ret = MDGD_ERROR_NONE;
+ GVariant *va;
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
LOG_BEGIN();
- device_data = mdgd_create_variant_device(mdgd_ctx->device);
- group_complete_get_local_device(group, invocation, device_data);
+ va = mdgd_create_variant_device_list(group_name);
+ group_complete_foreach_device(group, invocation, ret, va);
LOG_END();
gboolean group_regist_channel(Group *group, GDBusMethodInvocation *invocation,
gchar *channel_id, gpointer user_data)
{
- int ret = MDGD_ERROR_UNKNOWN;
+ int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
gboolean group_unregist_channel(Group *group, GDBusMethodInvocation *invocation,
gchar *channel_id, gpointer user_data)
{
- int ret = MDGD_ERROR_UNKNOWN;
+ int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
gchar *uuid, gchar *addr, int port, gchar *channel_id, GVariant *params,
gpointer user_data)
{
- int ret = MDGD_ERROR_UNKNOWN;
+ int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
int length = 0;
gboolean group_request_create_group(Group *group, GDBusMethodInvocation
*invocation, gchar *uuid, gchar *addr, int port, gchar *group_name, gpointer user_data)
{
- int ret = MDGD_ERROR_UNKNOWN;
+ int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
gboolean group_request_invite(Group *group, GDBusMethodInvocation *invocation,
gchar *uuid, gchar *addr, int port, gchar *group_name, gchar *target_uuid, gchar *PIN, gpointer user_data)
{
- int ret = MDGD_ERROR_UNKNOWN;
+ int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
gboolean group_request_eject(Group *group, GDBusMethodInvocation *invocation,
gchar *uuid, gchar *addr, int port, gchar *group_name, gchar *target_uuid, gpointer user_data)
{
- int ret = MDGD_ERROR_UNKNOWN;
+ int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
gboolean group_request_channel_list(Group *group, GDBusMethodInvocation *invocation,
gchar *uuid, gchar *addr, int port, gpointer user_data)
{
- int ret = MDGD_ERROR_UNKNOWN;
+ int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
NULL);
g_signal_connect(group_skeleton,
- "handle-get-member-device-list",
- G_CALLBACK(group_get_member_device_list),
+ "handle-foreach-device",
+ G_CALLBACK(group_foreach_device),
NULL);
g_signal_connect(group_skeleton,
int mdgd_group_delete(const char *name)
{
int ret = MDGD_ERROR_NONE;
- char *devices[256];
+ mdgd_device_t *devices[256];
int device_count = 0;
LOG_BEGIN();
/* Get all device in group */
mdgd_db_get_devices_in_group(name, devices, &device_count);
for (int i = 0; i < device_count; i++) {
- mdgd_db_device_delete(name, devices[i]);
+ mdgd_db_device_delete(name, devices[i]->device_id);
if (mdgd_db_check_device_exist(devices[i]) == false)
- agent_unpair("tmp", mdgd_ctx->device_uuid, devices[i]);
+ agent_unpair("tmp", mdgd_ctx->device_uuid, devices[i]->device_id);
}
/* delete group */
#define FULL_PERMISSION 31
-int mdgd_group_invite_device(char *sender, const char *group_name, const char *uuid, const char *pin)
+int mdgd_group_invite_device(char *sender, const char *group_name,
+ mdgd_device_t *device, const char *pin)
{
int ret = MDGD_ERROR_NONE;
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx, MDGD_ERROR_INVALID_PARAMETER);
- if (mdgd_db_check_device_exist_in_group(group_name, uuid)) {
+ if (mdgd_db_check_device_exist_in_group(group_name, device->device_id)) {
ret = MDGD_ERROR_ALREADY_REGISTERED;
} else {
- if (mdgd_db_check_device_exist(uuid) == false) {
- ret = agent_pair(sender, pin, mdgd_ctx->device_uuid, uuid, "/comp/data",
- "core.comp.data", "oic.if.baseline", FULL_PERMISSION, uuid,
+ if (mdgd_db_check_device_exist(device->device_id) == false) {
+ ret = agent_pair(sender, pin, mdgd_ctx->device_uuid, device->device_id, "/comp/data",
+ "core.comp.data", "oic.if.baseline", FULL_PERMISSION, device->device_id,
mdgd_ctx->device_uuid, "/comp/data", "core.comp.data",
"oic.if.baseline", FULL_PERMISSION);
}
if (MDGD_ERROR_NONE == ret)
- mdgd_db_device_insert(group_name, uuid);
+ mdgd_db_device_insert(group_name, device);
}
LOG_END();
LOG_DEBUG("group name : %s, UUID : %s", group_name.c_str(),
uuid.c_str());
+ /* find device, and invite this device. */
+
+/*
result = mdgd_group_invite_device("tmp", group_name.c_str(),
uuid.c_str(), "12341234");
+*/
break;
case MDGD_REQ_EJECT_DEVICE:
LOG_DEBUG("Request eject device");
LOG_ERR("Invalid Request Type");
}
- sleep(2);
pResponse->setRequestHandle(request->getRequestHandle());
pResponse->setResourceHandle(request->getResourceHandle());
pResponse->setErrorCode(200);
return "MDGD_ERROR_PERMISSION_DENIED";
case MDGD_ERROR_NOT_SUPPORTED:
return "MDGD_ERROR_NOT_SUPPORTED";
- case MDGD_ERROR_NO_DATA:
- return "MDGD_ERROR_NO_DATA";
case MDGD_ERROR_OPERATION_FAILED:
return "MDGD_ERROR_OPERATION_FAILED";
+ case MDGD_ERROR_NO_DATA:
+ return "MDGD_ERROR_NO_DATA";
+ case MDGD_ERROR_ALREADY_REGISTERED:
+ return "MDGD_ERROR_ALREADY_REGISTERED";
case MDGD_ERROR_IN_PROGRESS:
return "MDGD_ERROR_IN_PROGRESS";
case MDGD_ERROR_COMM_ERROR:
return "MDGD_ERROR_COMM_ERROR";
case MDGD_ERROR_PLUGIN_FAIL:
return "MDGD_ERROR_PLUGIN_FAIL";
- case MDGD_ERROR_ALREADY_IN_PROGRESS:
- return "MDGD_ERROR_ALREADY_IN_PROGRESS";
+ case MDGD_ERROR_NOT_STARTED:
+ return "MDGD_ERROR_NOT_STARTED";
+ case MDGD_ERROR_DB:
+ return "MDGD_ERROR_DB";
default:
return "UNKNOWN";
}
int agent_find_mot_enable_devices(char* sender, int timeout)
{
GVariant *variant = NULL;
- int result = MDGD_ERROR_UNKNOWN;
+ int result = MDGD_ERROR_NONE;
GError *error = NULL;
result = _check_agent_vaild();
int agent_find_mowned_devices(char* sender, int timeout)
{
GVariant *variant = NULL;
- int result = MDGD_ERROR_UNKNOWN;
+ int result = MDGD_ERROR_NONE;
GError *error = NULL;
result = _check_agent_vaild();
GError *error = NULL;
if (agent.dbus_connection != NULL)
- return MDGD_ERROR_ALREADY_IN_PROGRESS;
+ return MDGD_ERROR_IN_PROGRESS;
agent.dbus_connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
if (NULL == agent.dbus_connection) {
#include <mdgd_util.h>
-#define IPV6_ADDR_GLOBAL 0x0000U
-#define IPV6_ADDR_LOOPBACK 0x0010U
-#define IPV6_ADDR_LINKLOCAL 0x0020U
-#define IPV6_ADDR_SITELOCAL 0x0040U
-#define IPV6_ADDR_COMPATv4 0x0080U
-
-typedef struct _ipv4_info_s {
- char *ifname; /**< Network interface name */
- char *mac; /**< MAC address */
- bool active; /**< interface active or not */
- int mtu; /**< MTU size */
- char *ip; /**< IPv4 address */
- char *broadcast; /**< Broadcast address */
- char *mask; /**< Net-mask */
-} ipv4_info_s;
-
-typedef struct _ipv6_info_s {
- char *ifname; /**< Network interface name */
- char *ip; /**< IPv6 address */
- int prefix; /**< Prefix length */
- char *scope; /**< Scope */
-} ipv6_info_s;
-
-typedef struct _ip_info_s {
- GList *ipv4_list; /**< IPv4 address list */
- GList *ipv6_list; /**< IPv6 address list */
-} ip_info_s;
-
-ip_info_s g_ip_info; /**< Local IP address list */
-
-static void __free_ipv4_info(gpointer data)
-{
- ipv4_info_s *ipv4info = (ipv4_info_s *)data;
- if (NULL == data)
- return;
-
- if (ipv4info->ifname) {
- free(ipv4info->ifname);
- ipv4info->ifname = NULL;
- }
- if (ipv4info->mac) {
- free(ipv4info->mac);
- ipv4info->mac = NULL;
- }
- if (ipv4info->ip) {
- free(ipv4info->ip);
- ipv4info->ip = NULL;
- }
- if (ipv4info->broadcast) {
- free(ipv4info->broadcast);
- ipv4info->broadcast = NULL;
- }
- if (ipv4info->mask) {
- free(ipv4info->mask);
- ipv4info->mask = NULL;
- }
- free(ipv4info);
- ipv4info = NULL;
-}
-
-static void __free_ipv6_info(gpointer data)
-{
- ipv6_info_s *ipv6info = (ipv6_info_s *)data;
- if (NULL == data)
- return;
-
- if (ipv6info->ifname) {
- free(ipv6info->ifname);
- ipv6info->ifname = NULL;
- }
- if (ipv6info->ip) {
- free(ipv6info->ip);
- ipv6info->ip = NULL;
- }
- if (ipv6info->scope) {
- free(ipv6info->scope);
- ipv6info->scope = NULL;
- }
- free(ipv6info);
- ipv6info = NULL;
-}
-
-void mdgd_remove_ip_info(void)
-{
- if (g_ip_info.ipv4_list) {
- g_list_free_full(g_ip_info.ipv4_list, __free_ipv4_info);
- g_ip_info.ipv4_list = NULL;
- }
- if (g_ip_info.ipv6_list) {
- g_list_free_full(g_ip_info.ipv6_list, __free_ipv6_info);
- g_ip_info.ipv6_list = NULL;
- }
-}
-
-static void _parse_inet6(const char *ifname)
-{
- FILE *f;
- int scope, prefix;
- unsigned char ipv6[16];
- char dname[IFNAMSIZ];
- char address[INET6_ADDRSTRLEN];
- char *scopestr;
-
- f = fopen("/proc/net/if_inet6", "r");
- if (f == NULL) {
- LOG_ERR("Failed to access /proc/net/if_inet6");
- return;
- }
-
- while (19 == fscanf(f, " %2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx" \
- "%2hhx%2hhx%2hhx%2hhx%2hhx %*x %x %x %*x %s",
- &ipv6[0], &ipv6[1], &ipv6[2], &ipv6[3], &ipv6[4], &ipv6[5], &ipv6[6], &ipv6[7],
- &ipv6[8], &ipv6[9], &ipv6[10], &ipv6[11], &ipv6[12], &ipv6[13], &ipv6[14],
- &ipv6[15], &prefix, &scope, dname)) {
-
- if (strcmp(ifname, dname) != 0)
- continue;
-
- if (inet_ntop(AF_INET6, ipv6, address, sizeof(address)) == NULL)
- continue;
-
- ipv6_info_s *_ipv6 = calloc(1, sizeof(ipv6_info_s));
- if (NULL == _ipv6) {
- LOG_ERR("Memory allocation failed");
- goto FINISH_READING_IPV6;
- }
- _ipv6->ifname = g_strdup(ifname);
-
- switch (scope) {
- case IPV6_ADDR_GLOBAL:
- scopestr = "Global";
- break;
- case IPV6_ADDR_LINKLOCAL:
- scopestr = "Link";
- break;
- case IPV6_ADDR_SITELOCAL:
- scopestr = "Site";
- break;
- case IPV6_ADDR_COMPATv4:
- scopestr = "Compat";
- break;
- case IPV6_ADDR_LOOPBACK:
- scopestr = "Host";
- break;
- default:
- scopestr = "Unknown";
- }
- _ipv6->ip = g_strdup(address); /* ex) fe80::212:34ff:fe5a:ec0e */
- _ipv6->prefix = prefix; /* ex) 64 */
- _ipv6->scope = g_strdup(scopestr); /* Link */
-
- g_ip_info.ipv6_list = g_list_append(g_ip_info.ipv6_list, _ipv6);
- }
-FINISH_READING_IPV6:
- fclose(f);
-}
-
-static void _parse_ioctl(const char *ifname)
-{
- int sock;
- struct ifreq ifr;
- struct sockaddr_in *ipaddr;
- char address[INET_ADDRSTRLEN];
- size_t ifnamelen;
-
- /* copy ifname to ifr object */
- ifnamelen = strlen(ifname);
- if (ifnamelen >= sizeof(ifr.ifr_name))
- return;
-
- memcpy(ifr.ifr_name, ifname, ifnamelen);
- ifr.ifr_name[ifnamelen] = '\0';
-
- /* open socket */
- sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
- if (sock < 0) {
- LOG_ERR("socket creation faild");
- return;
- }
-
- ipv4_info_s *_ipv4 = calloc(1, sizeof(ipv4_info_s));
- if (NULL == _ipv4) {
- LOG_ERR("Memory allocation failed");
- goto FINISH_READING_IPV4;
- }
- _ipv4->ifname = g_strdup(ifname); /* ex) wlan0 */
-
- /* process mac */
- if (ioctl(sock, SIOCGIFHWADDR, &ifr) != -1) {
- char buf[64] = {0,};
- snprintf(buf, sizeof(buf), "%02x:%02x:%02x:%02x:%02x:%02x",
- ifr.ifr_hwaddr.sa_data[0], ifr.ifr_hwaddr.sa_data[1],
- ifr.ifr_hwaddr.sa_data[2], ifr.ifr_hwaddr.sa_data[3],
- ifr.ifr_hwaddr.sa_data[4], ifr.ifr_hwaddr.sa_data[5]);
- _ipv4->mac = g_strdup(buf); /* ex) 00:12:34:5a:ec:0e */
- }
-
- /* process mtu */
- if (ioctl(sock, SIOCGIFMTU, &ifr) != -1)
- _ipv4->mtu = ifr.ifr_mtu; /* ex) 1492 */
-
- /* die if cannot get address */
- if (ioctl(sock, SIOCGIFADDR, &ifr) == -1) {
- _ipv4->active = false;
- goto FINISH_READING_IPV4;
- }
-
- /* process ip */
- ipaddr = (struct sockaddr_in *)&ifr.ifr_addr;
- if (inet_ntop(AF_INET, &ipaddr->sin_addr, address, sizeof(address)) != NULL)
- _ipv4->ip = g_strdup(address); /* ex) 192.168.86.111 */
-
- /* try to get broadcast */
- if (ioctl(sock, SIOCGIFBRDADDR, &ifr) != -1) {
- ipaddr = (struct sockaddr_in *)&ifr.ifr_broadaddr;
- if (inet_ntop(AF_INET, &ipaddr->sin_addr, address, sizeof(address)) != NULL)
- _ipv4->broadcast = g_strdup(address); /* ex) 192.168.86.255 */
- }
-
- /* try to get mask */
- if (ioctl(sock, SIOCGIFNETMASK, &ifr) != -1) {
- ipaddr = (struct sockaddr_in *)&ifr.ifr_netmask;
- if (inet_ntop(AF_INET, &ipaddr->sin_addr, address, sizeof(address)) != NULL)
- _ipv4->mask = g_strdup(address); /* ex) 255.255.255.0 */
- }
-FINISH_READING_IPV4:
- close(sock);
- g_ip_info.ipv4_list = g_list_append(g_ip_info.ipv4_list, _ipv4);
-}
-
-
-int mdgd_make_ip_info(void)
-{
- DIR *d;
- struct dirent *de;
-
- d = opendir("/sys/class/net/");
- if (d == NULL) {
- LOG_ERR("Failed to access /sys/class/net/");
- return -1;
- }
-
- while (NULL != (de = readdir(d))) {
- if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0)
- continue;
-
- _parse_ioctl(de->d_name);
- _parse_inet6(de->d_name);
- }
- closedir(d);
-
- return 0;
-}
-
-int mdgd_is_local_ip(char *ipdata)
-{
- char *ip = NULL;
- char *ifname = NULL;
- char *save_str = NULL;
- char *addr = NULL;
- GList *iter = NULL;
- ipv6_info_s *ipv6info = NULL;
- ipv4_info_s *ipv4info = NULL;
-
- addr = g_strdup(ipdata);
-
- ip = strtok_r(addr, "%", &save_str);
- ifname = strtok_r(NULL, "%", &save_str);
-
- iter = g_list_first(g_ip_info.ipv6_list);
- while (NULL != iter) {
- ipv6info = iter->data;
- if (ipv6info && ipv6info->ip && !strncmp(ipv6info->ip, ip,
- INET6_ADDRSTRLEN)) {
- g_free(addr);
- return LOCAL_IP;
- }
- iter = g_list_next(iter);
- }
-
- iter = g_list_first(g_ip_info.ipv4_list);
- while (NULL != iter) {
- ipv4info = iter->data;
- if (ipv4info && ipv4info->ip && !strncmp(ipv4info->ip, ip,
- INET_ADDRSTRLEN)) {
- g_free(addr);
- return LOCAL_IP;
- }
- iter = g_list_next(iter);
- }
-
- g_free(addr);
- return REMOTE_IP;
-}
-
char *mdgd_addr2host(char *addr, int port, bool is_secure)
{
char ip[50];
GVariant *mdgd_create_variant_group(mdgd_group_t *group)
{
- GVariant *data;
+ GVariant *va;
GVariantBuilder *builder;
g_variant_builder_add(builder, "{sv}", "Type",
g_variant_new_int32(group->type));
- data = g_variant_builder_end(builder);
+ va = g_variant_builder_end(builder);
g_variant_builder_unref(builder);
- return data;
+ return va;
}
GVariant *mdgd_create_variant_device(mdgd_device_t *device)
{
- GVariant *data;
+ GVariant *va;
GVariantBuilder *builder;
g_variant_builder_add(builder, "{sv}", "Type",
g_variant_new_int32(device->type));
- data = g_variant_builder_end(builder);
+ va = g_variant_builder_end(builder);
g_variant_builder_unref(builder);
- return data;
+ return va;
}
GVariant *mdgd_create_variant_channel(mdgd_channel_t *channel)
{
- GVariant *data;
+ GVariant *va;
GVariantBuilder *builder;
g_variant_builder_add(builder, "{sv}", "ChannelID",
g_variant_new_string(channel->channel_id));
- data = g_variant_builder_end(builder);
+ va = g_variant_builder_end(builder);
g_variant_builder_unref(builder);
- return data;
+ return va;
}
GVariant *mdgd_create_variant_data(mdgd_data_t *data)
{
+ GVariant *va;
+
GVariantBuilder *builder;
GVariantBuilder *bytearray_builder = NULL;
GVariant *params = NULL;
g_variant_builder_add(builder, "{sv}", "DataLength",
g_variant_new_int32(data->data_length));
- data = g_variant_builder_end(builder);
+ va = g_variant_builder_end(builder);
g_variant_builder_unref(builder);
g_variant_builder_unref(bytearray_builder);
- return data;
+ return va;
}
+GVariant *mdgd_create_variant_device_list(char *group_name)
+{
+ GVariant *va;
+ GVariantBuilder *builder;
+
+ builder = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}"));
+
+ mdgd_device_t *devices[256];
+ int device_count = 0;
+
+ LOG_BEGIN();
+
+ /* Get all device in group */
+ mdgd_db_get_devices_in_group(group_name, devices, &device_count);
+
+ for (int i = 0; i < device_count; i++)
+ {
+ mdgd_device_t *device = devices[i];
+
+ g_variant_builder_open(builder, G_VARIANT_TYPE_VARDICT);
+
+ g_variant_builder_add(builder, "{sv}", "DeviceID",
+ g_variant_new_string(device->device_id));
+ g_variant_builder_add(builder, "{sv}", "Port",
+ g_variant_new_int32(device->port));
+ g_variant_builder_add(builder, "{sv}", "Addr",
+ g_variant_new_string(device->addr));
+ g_variant_builder_add(builder, "{sv}", "ConnType",
+ g_variant_new_int32(device->conn_type));
+ g_variant_builder_add(builder, "{sv}", "SecurePort",
+ g_variant_new_int32(device->secure_port));
+ g_variant_builder_add(builder, "{sv}", "ModelName",
+ g_variant_new_string(device->model_name));
+ g_variant_builder_add(builder, "{sv}", "DeviceName",
+ g_variant_new_string(device->device_name));
+ g_variant_builder_add(builder, "{sv}", "PlatformVer",
+ g_variant_new_string(device->platform_ver));
+ g_variant_builder_add(builder, "{sv}", "VendorID",
+ g_variant_new_string(device->vendor_id));
+ g_variant_builder_add(builder, "{sv}", "Profile",
+ g_variant_new_string(device->profile));
+ g_variant_builder_add(builder, "{sv}", "IsInvited",
+ g_variant_new_int32(device->is_invited));
+ g_variant_builder_add(builder, "{sv}", "Type",
+ g_variant_new_int32(device->type));
+
+ g_variant_builder_close(builder);
+ }
+
+ va = g_variant_builder_end(builder);
+ g_variant_builder_unref(builder);
+
+ return va;
+}
GVariant *mdgd_create_variant_dummy()
{
- GVariant *data;
+ GVariant *va;
GVariantBuilder *builder;
builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- data = g_variant_builder_end(builder);
+ va = g_variant_builder_end(builder);
g_variant_builder_unref(builder);
- return data;
+ return va;
+}
+
+mdgd_device_t *mdgd_get_device_from_variant(GVariant *va)
+{
+ char *device_id = NULL;
+ char *addr = NULL;
+ int port;
+ int secure_port;
+ int conn_type;
+ char *model_name = NULL;
+ char *device_name = NULL;
+ char *platform_ver = NULL;
+ char *vendor_id = NULL;
+ char *profile = NULL;
+ bool is_invited;
+ int type = MDGD_DEVICE_TYPE_LOCAL;
+ GVariantIter *iter = NULL;
+ const gchar *key;
+ GVariant *key_value = NULL;
+
+ mdgd_device_t *device = calloc(1, sizeof(mdgd_device_t));
+ if (NULL == device) {
+ /* LCOV_EXCL_START */
+ LOG_ERR("Memory allocation failed");
+ return NULL;
+ /* LCOV_EXCL_STOP */
+ }
+
+ g_variant_get(va, "a{sv}", &iter);
+ while (g_variant_iter_loop(iter, "{sv}", &key, &key_value)) {
+ if (g_strcmp0(key, "DeviceID") == 0)
+ device_id = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "Addr") == 0)
+ addr = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "Port") == 0)
+ port = g_variant_get_int32(key_value);
+ else if (g_strcmp0(key, "SecurePort") == 0)
+ secure_port = g_variant_get_int32(key_value);
+ else if (g_strcmp0(key, "ConnType") == 0)
+ conn_type = g_variant_get_int32(key_value);
+ else if (g_strcmp0(key, "ModelName") == 0)
+ model_name = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "DeviceName") == 0)
+ device_name = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "PlatformVer") == 0)
+ platform_ver = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "VendorID") == 0)
+ vendor_id = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "Profile") == 0)
+ profile = (char *)g_variant_get_string(key_value, NULL);
+ else if (g_strcmp0(key, "IsInvited") == 0)
+ is_invited = g_variant_get_int32(key_value);
+ else if (g_strcmp0(key, "Type") == 0)
+ type = g_variant_get_int32(key_value);
+ }
+
+ device->device_id = g_strdup(device_id);
+ device->addr = g_strdup(addr);
+ device->port = port;
+ device->secure_port = secure_port;
+ device->conn_type = conn_type;
+ device->model_name = g_strdup(model_name);
+ device->device_name = g_strdup(device_name);
+ device->platform_ver = g_strdup(platform_ver);
+ device->vendor_id = g_strdup(vendor_id);
+ device->profile = g_strdup(profile);
+ device->is_invited = is_invited;
+ device->type = type;
+
+ g_variant_iter_free(iter);
+
+ return device;
}
projects / platform / core / connectivity / mdg-manager.git / commitdiff