int mdgd_group_regist_channel(char *sender, char *channel_id);
int mdgd_group_unregist_channel(char *sender, char *channel_id);
-int mdgd_group_send_data(char *sender, char *uuid, char *addr, int port, char *channel_id,
+int mdgd_group_send_data(char *sender, char *uuid, 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_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);
+int mdgd_group_request(mdgd_request_type_e type, char *sender, char *uuid,
+ char *arg1, char *arg2, char *arg3, void *user_data);
/* send signal to client */
int mdgd_group_notify_event(char *sender, mdgd_event_type_e type, int result, void *user_data);
int mdgd_iot_initialize();
int mdgd_iot_add_resource(mdgd_resource_type_e resource_type, const char *uri);
int mdgd_iot_discovery_resource(mdgd_resource_type_e resource_type, void *user_data);
-int mdgd_iot_send_data(mdgd_resource_type_e resource_type, mdgd_command_t *cmd);
-int mdgd_iot_get_device_description(mdgd_command_t *cmd);
+int mdgd_iot_get_device_description(mdgd_command_t *cmd, char *host_addr, int conn_type);
int mdgd_iot_deinitialize();
#ifdef __cplusplus
typedef struct {
char *device_id; /**< Device ID */
- char *host_addr; /**< IP Address of remote device */
char *group_name; /**< Group name */
mdgd_group_type_e type; /**< Group type */
char *sender;
typedef struct {
char *device_id; /**< Device Id */
- int port; /**< Remtoe device is listening this port */
- char *addr; /**< IP Address of remote device */
- unsigned int conn_type; /**< Connection type */
- int secure_port; /**< Secured port once TLS handhaking complete */
char *model_name; /**< Device ID */
char *device_name; /**< Host address */
char *platform_ver; /**< Group name */
mdgd_device_type_e type; /**< Group type */
} mdgd_device_t;
+typedef struct {
+ char *device_id; /**< Device Id */
+ char *file_path;
+} mdgd_receive_file_t;
+
typedef struct {
char *device_id;
char *channel_id;
} mdgd_conn_destroy_data;
typedef struct {
- int tid; /**< Timer ID */
int resource_type; /**< OCF resource type */
- mdgd_request_type_e command; /**< Comments set for group management */
+ mdgd_request_type_e type; /**< Comments set for group management */
gchar *uuid; /**< Device UUID */
- gchar *host; /**< Host address + Port */
gchar *addr; /**< Host address + Port */
gchar *sender; /**< Dbus Sender */
gchar *arg1; /**< Arguement #1 */
gchar *arg2; /**< Arguement #2 */
gchar *arg3; /**< Arguement #3 */
- gchar *arg4; /**< Arguement #4 */
#ifdef SUPPORT_BASE64_ENCODING
unsigned char *data;
int data_len;
void mdgd_clean_user_data(void *user_data);
GVariant *mdgd_create_variant_group(mdgd_group_t *group);
GVariant *mdgd_create_variant_device(mdgd_device_t *device);
+GVariant *mdgd_create_variant_receive_file(mdgd_receive_file_t *receive_file);
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);
</method>
<method name="SendData">
<arg type="s" name="uuid" direction="in" />
- <arg type="s" name="addr" direction="in"/>
- <arg type="i" name="port" direction="in"/>
<arg type="s" name="channel_id" direction="in"/>
<arg type="(iay)" name="data" direction="in"/>
<arg type="i" name="result" direction="out" />
</method>
<method name="SendFile">
<arg type="s" name="uuid" direction="in" />
- <arg type="s" name="addr" direction="in"/>
- <arg type="i" name="port" direction="in"/>
<arg type="s" name="file_path" direction="in"/>
<arg type="i" name="result" direction="out" />
</method>
<method name="RequestCreateGroup">
<arg type="s" name="uuid" direction="in" />
- <arg type="s" name="addr" direction="in"/>
- <arg type="i" name="port" direction="in"/>
<arg type="s" name="group_name" direction="in" />
<arg type="i" name="result" direction="out" />
</method>
<method name="RequestInvite">
<arg type="s" name="uuid" direction="in" />
- <arg type="s" name="addr" direction="in"/>
- <arg type="i" name="port" direction="in"/>
<arg type="s" name="group_name" direction="in" />
<arg type="s" name="target_uuid" direction="in" />
<arg type="s" name="pin" direction="in" />
</method>
<method name="RequestEject">
<arg type="s" name="uuid" direction="in" />
- <arg type="s" name="addr" direction="in"/>
- <arg type="i" name="port" direction="in"/>
<arg type="s" name="group_name" direction="in" />
<arg type="s" name="target_uuid" direction="in" />
<arg type="i" name="result" direction="out" />
</method>
<method name="RequestChannelList">
<arg type="s" name="uuid" direction="in" />
- <arg type="s" name="addr" direction="in"/>
- <arg type="i" name="port" direction="in"/>
<arg type="i" name="result" direction="out" />
</method>
<!-- Signal (D-Bus) definitions -->
return -1;
}
- 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);",
+ sql = sqlite3_mprintf("CREATE TABLE %s(id INTEGER PRIMARY KEY, group_name TEXT, device_id TEXT, 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 -1;
}
- 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);",
+ sql = sqlite3_mprintf("INSERT INTO %s (group_name, device_id, model_name, device_name, platform_ver, vendor_id, profile, is_invited, type) values(%Q, %Q, %Q, %Q, %Q, %Q, %Q, %d, %d);",
MDGD_DB_DEVICE_TABLE,
group_name,
device->device_id,
- device->port,
- device->addr,
- device->conn_type,
- device->secure_port,
device->model_name,
device->device_name,
device->platform_ver,
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);
+ devices[i]->model_name = g_strdup(sqlite3_column_text(stmt, 3));
+ devices[i]->device_name = g_strdup(sqlite3_column_text(stmt, 4));
+ devices[i]->platform_ver = g_strdup(sqlite3_column_text(stmt, 5));
+ devices[i]->vendor_id = g_strdup(sqlite3_column_text(stmt, 6));
+ devices[i]->profile = g_strdup(sqlite3_column_text(stmt, 7));
+ devices[i]->is_invited = sqlite3_column_int(stmt, 8);
+ devices[i]->type = sqlite3_column_int(stmt, 9);
i++;
}
}
gboolean group_send_data(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gchar *addr, int port, gchar *channel_id, GVariant *params,
- gpointer user_data)
+ gchar *uuid, gchar *channel_id, GVariant *params, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
g_variant_iter_free(iter);
- ret = mdgd_group_send_data(sender, uuid, addr, port, channel_id, data, len);
+ ret = mdgd_group_send_data(sender, uuid, channel_id, data, len);
group_complete_send_data(group, invocation, ret);
}
gboolean group_send_file(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gchar *addr, int port, gchar *file_path, gpointer user_data)
+ gchar *uuid, gchar *file_path, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
- ret = mdgd_group_send_file(sender, uuid, addr, port, file_path);
+ ret = mdgd_group_request(MDGD_REQ_SEND_FILE, sender, uuid,
+ file_path, NULL, NULL, NULL);
+
group_complete_send_file(group, invocation, ret);
LOG_END();
}
gboolean group_request_create_group(Group *group, GDBusMethodInvocation
- *invocation, gchar *uuid, gchar *addr, int port, gchar *group_name, gpointer user_data)
+ *invocation, gchar *uuid, gchar *group_name, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
- ret = mdgd_group_request_create_group(sender, uuid, addr, port, group_name);
+ ret = mdgd_group_request(MDGD_REQ_CREATE_GROUP, sender, uuid,
+ group_name, NULL, NULL, NULL);
+
group_complete_request_create_group(group, invocation, ret);
LOG_END();
}
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)
+ gchar *uuid, gchar *group_name, gchar *target_uuid, gchar *PIN, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
- ret = mdgd_group_request_invite(sender, uuid, addr, port, group_name, target_uuid, PIN);
+ ret = mdgd_group_request(MDGD_REQ_INVITE_DEVICE, sender, uuid,
+ group_name, target_uuid, PIN, NULL);
+
group_complete_request_invite(group, invocation, ret);
LOG_END();
}
gboolean group_request_eject(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gchar *addr, int port, gchar *group_name, gchar *target_uuid, gpointer user_data)
+ gchar *uuid, gchar *group_name, gchar *target_uuid, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
- ret = mdgd_group_request_eject(sender, uuid, addr, port, group_name, target_uuid);
+ ret = mdgd_group_request(MDGD_REQ_EJECT_DEVICE, sender, uuid,
+ group_name, target_uuid, NULL, NULL);
+
group_complete_request_eject(group, invocation, ret);
LOG_END();
}
gboolean group_request_channel_list(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gchar *addr, int port, gpointer user_data)
+ gchar *uuid, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
- ret = mdgd_group_request_channel_list(sender, uuid, addr, port);
+ ret = mdgd_group_request(MDGD_REQ_CHANNEL_LIST, sender, uuid,
+ NULL, NULL, NULL, NULL);
+
group_complete_request_channel_list(group, invocation, ret);
LOG_END();
return ret;
}
-int mdgd_group_send_data(char *sender, char *uuid, char *addr, int port, char *channel_id,
+int mdgd_group_send_data(char *sender, char *uuid, char *channel_id,
unsigned char *data, int len)
{
int ret;
return ret;
}
- cmd->command = MDGD_REQ_SEND_DATA;
+ cmd->resource_type = MDGD_RESOURCE_TYPE_DATA;
+ cmd->type = MDGD_REQ_SEND_DATA;
cmd->uuid = g_strdup(uuid);
cmd->sender = g_strdup(sender);
- cmd->host = mdgd_addr2host(addr, port, true);
cmd->arg1 = g_strdup(channel_id);
#ifdef SUPPORT_BASE64_ENCODING
cmd->data = g_try_malloc0(len + 1);
if (NULL == cmd->data) {
ret = MDGD_ERROR_OUT_OF_MEMORY;
- LOG_ERR("Send Data Fail to uuid = %s host %s error=%s",
- cmd->uuid, cmd->host, mdgd_log_get_error_string(ret));
+ LOG_ERR("Send Data Fail to uuid = %s error=%s",
+ cmd->uuid, mdgd_log_get_error_string(ret));
return ret;
}
cmd->data_len = len;
#else
cmd->arg2 = g_try_malloc0(len + 1);
- if (NULL == cmd->arg1) {
+ if (NULL == cmd->arg2) {
ret = MDGD_ERROR_OUT_OF_MEMORY;
- LOG_ERR("Send Data Fail to uuid = %s host %s error=%s",
- cmd->uuid, cmd->host, mdgd_log_get_error_string(ret));
+ LOG_ERR("Send Data Fail to uuid = %s error=%s",
+ cmd->uuid, mdgd_log_get_error_string(ret));
return ret;
}
cmd->arg2[len] = '\0';
#endif
- LOG_DEBUG("UUID %s host %s", cmd->uuid, cmd->host);
-
- ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, cmd);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to send data : %s",
- mdgd_log_get_error_string(ret));
- }
+ ret = mdgd_iot_discovery_resource(cmd->resource_type, cmd);
LOG_END();
return ret;
}
-int mdgd_group_send_file(char *sender, char *uuid, char *addr, int port, char *file_path)
+
+int mdgd_group_request(mdgd_request_type_e type, char *sender, char *uuid,
+ char *arg1, char *arg2, char *arg3, void *user_data)
{
int ret;
return ret;
}
- cmd->command = MDGD_REQ_SEND_FILE;
- cmd->uuid = g_strdup(uuid);
- cmd->sender = g_strdup(sender);
- cmd->addr = g_strdup(addr);
- cmd->host = mdgd_addr2host(addr, port, true);
- cmd->arg1 = g_strdup(file_path);
-
- LOG_DEBUG("UUID %s host %s, file path %s", cmd->uuid, cmd->host, cmd->arg1);
-
- ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, cmd);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to send data : %s",
- mdgd_log_get_error_string(ret));
- }
-
- LOG_END();
-
- return ret;
-}
-
-int mdgd_group_request_create_group(char *sender, char *uuid, char *addr, int port,
- char *group_name)
-{
- int ret = MDGD_ERROR_NONE;
-
- LOG_BEGIN();
-
- mdgd_command_t *cmd = g_new0(mdgd_command_t, 1);
- cmd->command = MDGD_REQ_CREATE_GROUP;
+ cmd->resource_type = MDGD_RESOURCE_TYPE_DATA;
+ cmd->type = type;
cmd->uuid = g_strdup(uuid);
- cmd->arg1 = g_strdup(group_name);
cmd->sender = g_strdup(sender);
- cmd->host = mdgd_addr2host(addr, port, true);
+ cmd->user_data = user_data;
- LOG_DEBUG("UUID %s host %s", cmd->uuid, cmd->host);
+ if (arg1 != NULL)
+ cmd->arg1 = g_strdup(arg1);
+ if (arg2 != NULL)
+ cmd->arg2 = g_strdup(arg2);
+ if (arg3 != NULL)
+ cmd->arg3 = g_strdup(arg3);
- ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, cmd);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to send data : %s",
- mdgd_log_get_error_string(ret));
- }
-
- LOG_END();
-
- return ret;
-}
-
-int mdgd_group_request_invite(char *sender, char *uuid, char *addr, int port,
- char *group_name, char *target_uuid, char *PIN)
-{
- int ret = MDGD_ERROR_NONE;
-
- LOG_BEGIN();
-
- mdgd_command_t *cmd = g_new0(mdgd_command_t, 1);
- cmd->command = MDGD_REQ_INVITE_DEVICE;
- cmd->uuid = g_strdup(uuid);
- cmd->arg1 = g_strdup(group_name);
- cmd->arg2 = g_strdup(target_uuid);
- cmd->arg3 = g_strdup(PIN);
- cmd->sender = g_strdup(sender);
- cmd->host = mdgd_addr2host(addr, port, true);
-
- LOG_DEBUG("UUID %s host %s", cmd->uuid, cmd->host);
-
- ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, cmd);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to send data : %s",
- mdgd_log_get_error_string(ret));
- }
-
- LOG_END();
-
- return ret;
-}
-
-int mdgd_group_request_eject(char *sender, char *uuid, char *addr, int port,
- char *group_name, char *target_uuid)
-{
- int ret = MDGD_ERROR_NONE;
-
- LOG_BEGIN();
-
- mdgd_command_t *cmd = g_new0(mdgd_command_t, 1);
- cmd->command = MDGD_REQ_EJECT_DEVICE;
- cmd->uuid = g_strdup(uuid);
- cmd->arg1 = g_strdup(group_name);
- cmd->arg2 = g_strdup(target_uuid);
- cmd->sender = g_strdup(sender);
- cmd->host = mdgd_addr2host(addr, port, true);
-
- LOG_DEBUG("UUID %s host %s", cmd->uuid, cmd->host);
-
- ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, cmd);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to send data : %s",
- mdgd_log_get_error_string(ret));
- }
-
- LOG_END();
-
- return ret;
-}
-
-int mdgd_group_request_channel_list(char *sender, char *uuid, char *addr, int port)
-{
- int ret = MDGD_ERROR_NONE;
-
- LOG_BEGIN();
-
- mdgd_command_t *cmd = g_new0(mdgd_command_t, 1);
- cmd->command = MDGD_REQ_CHANNEL_LIST;
- cmd->uuid = g_strdup(uuid);
- cmd->sender = g_strdup(sender);
- cmd->host = mdgd_addr2host(addr, port, true);
-
- LOG_DEBUG("UUID %s host %s", cmd->uuid, cmd->host);
-
- ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, cmd);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to send data : %s",
- mdgd_log_get_error_string(ret));
- }
+ ret = mdgd_iot_discovery_resource(cmd->resource_type, cmd);
LOG_END();
case MDGD_EVENT_RECEIVE_DATA:
va = mdgd_create_variant_data((mdgd_data_t *)user_data);
break;
+ case MDGD_EVENT_RECEIVE_FILE:
+ va = mdgd_create_variant_receive_file((mdgd_receive_file_t *)user_data);
+ break;
default:
LOG_ERR("Unknown event : %d", type);
break;
OC::ServiceType::InProc,
OC::ModeType::Both,
(OCTransportAdapter)(OCTransportAdapter::OC_ADAPTER_IP),
- OC::QualityOfService::LowQos,
+ OC::QualityOfService::HighQos,
&ps
};
system_info_get_platform_string(SYSTEM_INFO_PROFILE, &profile);
device->device_id = device_id;
- device->port = iter->endpoint.port;
- device->addr = g_strdup(iter->endpoint.addr);
- device->conn_type = iter->connType;
- device->secure_port = iter->securePort;
device->device_name = g_strdup(device_name);
device->model_name = g_strdup(model_name);
device->platform_ver = g_strdup(platform_ver);
#define MAXBUF 1024
/* FILE Send in thread */
-static gpointer file_send_thread_func(gpointer user_data)
+static gpointer __file_send_thread_func(gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
int sock;
- struct sockaddr_in6 serveraddr;
+ struct sockaddr_in serveraddr;
int retval;
mdgd_command_t *cmd = (mdgd_command_t *)user_data;
long num_read;
char buf[MAXBUF];
long total_bytes;
char tempaddr[26] = {0,};
+ char *tmpaddr;
LOG_BEGIN();
goto SEND_THREAD_EXIT;
}
- sock = socket(AF_INET6, SOCK_STREAM, 0);
+ sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock < 0) {
LOG_ERR("socket() error");
ret = MDGD_ERROR_OPERATION_FAILED;
goto SEND_THREAD_EXIT;
}
- serveraddr.sin6_family = AF_INET6;
- serveraddr.sin6_port = htons(PORT);
- serveraddr.sin6_flowinfo = 0;
- serveraddr.sin6_scope_id = if_nametoindex("wlan0");
+ serveraddr.sin_family = AF_INET;
+ serveraddr.sin_port = htons(PORT);
- strncpy(tempaddr, cmd->addr, 25);
- inet_pton(AF_INET6, tempaddr, &serveraddr.sin6_addr);
+ sscanf(cmd->addr, "coaps://%s", &tempaddr);
+ strtok(tempaddr, ":");
+
+ inet_pton(AF_INET, tempaddr, &serveraddr.sin_addr.s_addr);
retval = connect(sock, (struct sockaddr*) &serveraddr, sizeof(serveraddr));
if(retval < 0) {
LOG_ERR("connect() error : %s", strerror(errno));
return NULL;
}
-void __get_group_information(const HeaderOptions& headerOptions,
+static void __get_group_information(const HeaderOptions& headerOptions,
const OCRepresentation& rep, const int eCode, void *user_data)
{
int ret;
LOG_END();
}
+static void __request_finish(const HeaderOptions&,
+ const OCRepresentation& rep, const int eCode,
+ void *user_data)
+{
+ int ret = MDGD_ERROR_NONE;
+
+ mdgd_check_null_ret("user_data", user_data);
+ mdgd_command_t *cmd = (mdgd_command_t *)user_data;
+
+ LOG_BEGIN();
+
+ try {
+ if (eCode == OC_STACK_OK || eCode == OC_STACK_RESOURCE_CREATED ||
+ eCode == OC_STACK_RESOURCE_CHANGED) {
+ if (cmd->type == MDGD_REQ_CHANNEL_LIST) {
+ std::map<std::string, AttributeValue> channel_list = rep.getValues();
+ std::map<std::string, AttributeValue>::iterator iter;
+
+ for (iter = channel_list.begin(); iter != channel_list.end(); ++iter) {
+ std::string channel_id = (*iter).first;
+ mdgd_channel_t *channel = g_new0(mdgd_channel_t, 1);
+ channel->device_id = g_strdup(cmd->uuid);
+ channel->channel_id = g_strdup(channel_id.c_str());
+ mdgd_group_notify_event(cmd->sender, MDGD_EVENT_REQ_CHANNEL_LIST_FINISH, ret, (void *)channel);
+ }
+ } else if (cmd->type == MDGD_REQ_SEND_DATA) {
+ mdgd_group_notify_event(cmd->sender, MDGD_EVENT_SEND_DATA_FINISH, ret, NULL);
+ } else if (cmd->type == MDGD_REQ_SEND_FILE) {
+ GError *error = NULL;
+ g_thread_try_new("file_send_thread", __file_send_thread_func, cmd, &error);
+ }
+ } else {
+ LOG_ERR("__get_device_description Response error %d", eCode);
+ }
+ } catch(std::exception& e) {
+ LOG_ERR("Exception %s in on get", e.what());
+ }
+
+ LOG_END();
+}
+
static bool _found_resource(std::shared_ptr<OCResource> resource,
void *user_data)
{
resource_type = g_strdup(resourceTypes.c_str());
}
- if (g_strcmp0(resource_type, mdgd_resource_get_type(MDGD_RESOURCE_TYPE_GROUP)) == 0) {
+ if (g_strcmp0(resource_type,
+ mdgd_resource_get_type(MDGD_RESOURCE_TYPE_GROUP)) == 0) {
mdgd_group_t *group = (mdgd_group_t *)g_try_malloc0(sizeof(mdgd_group_t));
group->device_id = g_strdup(resource->sid().c_str());
- group->host_addr = g_strdup(resource->host().c_str());
group->sender = g_strdup(cmd->sender);
if (g_strcmp0(group->device_id, mdgd_ctx->device_uuid) != 0) {
group->type = MDGD_GROUP_TYPE_REMOTE;
resource->get(QueryParamsMap(), std::bind(&__get_group_information,
std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, group));
+ } else if (g_strcmp0(resource_type,
+ mdgd_resource_get_type(MDGD_RESOURCE_TYPE_DATA)) == 0 &&
+ g_strcmp0(cmd->uuid, resource->sid().c_str()) == 0) {
+ OCRepresentation rep;
+ rep.setValue("CMD", cmd->type);
+
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+ rep.setValue("device_id", std::string(mdgd_ctx->device_uuid));
+
+ LOG_DEBUG("request type is %d", cmd->type);
+ switch (cmd->type) {
+ case MDGD_REQ_SEND_FILE:
+ rep.setValue("file_path", std::string(cmd->arg1));
+ cmd->addr = g_strdup(resource->host().c_str());
+ break;
+ case MDGD_REQ_SEND_DATA:
+ {
+ rep.setValue("channel_id", std::string(cmd->arg1));
+#ifdef SUPPORT_BASE64_ENCODING
+ uint32_t outSize = 0;
+ size_t b64BufSize;
+ char *b64Buf;
+
+ b64BufSize = B64ENCODE_OUT_SAFESIZE((cmd->data_len + 1));
+ b64Buf = (char *) g_try_malloc0(b64BufSize + 1);
+ if (NULL == b64Buf) {
+ mdgd_clean_user_data(cmd);
+ return TRUE;
+ }
+ b64Encode(cmd->data, cmd->data_len,
+ b64Buf, b64BufSize, &outSize);
+ rep.setValue("data", std::string(b64Buf));
+ rep.setValue("data_length", to_string(outSize));
+ LOG_DEBUG("b64BufSize = %d outSize = %d b64Buf = %s",
+ b64BufSize, outSize, b64Buf);
+ g_free(b64Buf);
+#else
+ rep.setValue("data", std::string(cmd->arg2));
+#endif
+ break;
+ }
+ case MDGD_REQ_CREATE_GROUP:
+ rep.setValue("name", std::string(cmd->arg1));
+ break;
+ case MDGD_REQ_INVITE_DEVICE:
+ rep.setValue("name", std::string(cmd->arg1));
+ rep.setValue("id", std::string(cmd->arg2));
+ rep.setValue("PIN", std::string(cmd->arg3));
+ break;
+ case MDGD_REQ_EJECT_DEVICE:
+ rep.setValue("name", std::string(cmd->arg1));
+ rep.setValue("id", std::string(cmd->arg2));
+ break;
+ case MDGD_REQ_CHANNEL_LIST:
+ break;
+ default:
+ LOG_ERR("Invalid command %d", cmd->type);
+ return FALSE;
+ }
+
+ resource->post(rep, QueryParamsMap(), std::bind (&__request_finish,
+ std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, cmd));
}
}
else {
requestURI << OC_RSRVD_WELL_KNOWN_URI << "?rt=" <<
mdgd_resource_get_type(resource_type);
- auto found_cb = std::bind (&_found_resource, std::placeholders::_1,
- cmd);
-
- if (cmd) {
- LOG_DEBUG("Querying for Resource host address %s",
- cmd->host ? cmd->host : "NULL");
-
- if (cmd->host)
- ret = OCPlatform::findResource(cmd->host, requestURI.str(),
- CT_ADAPTER_IP,
- found_cb);
- else
- ret = OCPlatform::findResource("", requestURI.str(),
- CT_ADAPTER_IP,
- found_cb);
- }
+ auto found_cb = std::bind (&_found_resource, std::placeholders::_1, cmd);
+
+ ret = OCPlatform::findResource("", requestURI.str(), CT_IP_USE_V4, found_cb);
+
} catch (OCException &e) {
LOG_ERR("Failed to find resource %s", e.what());
ret = e.code();
LOG_END();
}
-int mdgd_iot_get_device_description(mdgd_command_t *cmd)
+int mdgd_iot_get_device_description(mdgd_command_t *cmd, char *host_addr, int conn_type)
{
+ int ret;
std::string uri_path;
std::vector<std::string> resource_types = {"core.comp.device"};
std::vector<std::string> ifaces = {DEFAULT_INTERFACE};
- char *host_addr = NULL;
- mdgd_device_t *device = (mdgd_device_t *)(cmd->user_data);
LOG_BEGIN();
uri_path = std::string(mdgd_resource_get_uri_prefix(MDGD_RESOURCE_TYPE_DEVICE));
- host_addr = mdgd_addr2host(device->addr, device->port, false);
OCResource::Ptr device_resource = OCPlatform::constructResourceObject(std::string(host_addr),
- uri_path, (OCConnectivityType)device->conn_type, false, resource_types, ifaces);
+ uri_path, (OCConnectivityType)conn_type, false, resource_types, ifaces);
- device_resource->get(QueryParamsMap(), std::bind (&__get_device_description, std::placeholders::_1,
+ ret = device_resource->get(QueryParamsMap(), std::bind (&__get_device_description, std::placeholders::_1,
std::placeholders::_2, std::placeholders::_3, cmd));
LOG_END();
-}
-
-static void __send_data_finish(const HeaderOptions&,
- const OCRepresentation& rep, const int eCode,
- void *user_data)
-{
- int ret = MDGD_ERROR_NONE;
-
- mdgd_check_null_ret("user_data", user_data);
- mdgd_command_t *cmd = (mdgd_command_t *)user_data;
-
- LOG_BEGIN();
-
- try {
- if (eCode == OC_STACK_OK || eCode == OC_STACK_RESOURCE_CREATED ||
- eCode == OC_STACK_RESOURCE_CHANGED) {
- if (cmd->command == MDGD_REQ_CHANNEL_LIST) {
- std::map<std::string, AttributeValue> channel_list = rep.getValues();
- std::map<std::string, AttributeValue>::iterator iter;
-
- for (iter = channel_list.begin(); iter != channel_list.end(); ++iter) {
- std::string channel_id = (*iter).first;
- mdgd_channel_t *channel = g_new0(mdgd_channel_t, 1);
- channel->device_id = g_strdup(cmd->uuid);
- channel->channel_id = g_strdup(channel_id.c_str());
- mdgd_group_notify_event(cmd->sender, MDGD_EVENT_REQ_CHANNEL_LIST_FINISH, ret, (void *)channel);
- }
- } else if (cmd->command == MDGD_REQ_SEND_DATA) {
- mdgd_group_notify_event(cmd->sender, MDGD_EVENT_SEND_DATA_FINISH, ret, NULL);
- } else if (cmd->command == MDGD_REQ_SEND_FILE) {
- GError *error = NULL;
- g_thread_try_new("file_send_thread", file_send_thread_func, cmd, &error);
- }
- } else {
- LOG_ERR("__get_device_description Response error %d", eCode);
- }
- } catch(std::exception& e) {
- LOG_ERR("Exception %s in on get", e.what());
- }
-
- //__clean_user_data(cmd);
-}
-
-int mdgd_iot_send_data(mdgd_resource_type_e resource_type, mdgd_command_t *cmd)
-{
- int ret;
- OCResource::Ptr resource;
- std::string requestURI;
- std::vector<std::string> ifaces = {DEFAULT_INTERFACE};
- std::vector<std::string> resource_types;
- resource_types = {mdgd_resource_get_type(resource_type)};
-
- try {
- requestURI = std::string(mdgd_resource_get_uri_prefix(resource_type));
-
- LOG_DEBUG("Request URI %s", requestURI.c_str());
-
- resource = OCPlatform::constructResourceObject(std::string(cmd->host),
- requestURI, CT_ADAPTER_IP, false,
- resource_types, ifaces);
- if (!resource) {
- LOG_ERR("Failed to construct resource");
- return -1;
- }
-
- OCRepresentation rep;
- rep.setValue("CMD", cmd->command);
-
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
- rep.setValue("device_id", std::string(mdgd_ctx->device_uuid));
-
-#ifdef SUPPORT_BASE64_ENCODING
- uint32_t outSize = 0;
- size_t b64BufSize;
- char *b64Buf;
-#endif
- switch (cmd->command) {
- case MDGD_REQ_SEND_FILE:
- rep.setValue("file_path", std::string(cmd->arg1));
- break;
- case MDGD_REQ_SEND_DATA:
- rep.setValue("channel_id", std::string(cmd->arg1));
-#ifdef SUPPORT_BASE64_ENCODING
- b64BufSize = B64ENCODE_OUT_SAFESIZE((cmd->data_len + 1));
- b64Buf = (char *) g_try_malloc0(b64BufSize + 1);
- if (NULL == b64Buf) {
- mdgd_clean_user_data(cmd);
- return TRUE;
- }
- b64Encode(cmd->data, cmd->data_len,
- b64Buf, b64BufSize, &outSize);
- rep.setValue("data", std::string(b64Buf));
- rep.setValue("data_length", to_string(outSize));
- LOG_DEBUG("b64BufSize = %d outSize = %d b64Buf = %s",
- b64BufSize, outSize, b64Buf);
- g_free(b64Buf);
-#else
- rep.setValue("data", std::string(cmd->arg2));
-#endif
- break;
- case MDGD_REQ_CREATE_GROUP:
- rep.setValue("name", std::string(cmd->arg1));
- break;
- case MDGD_REQ_INVITE_DEVICE:
- rep.setValue("name", std::string(cmd->arg1));
- rep.setValue("id", std::string(cmd->arg2));
- rep.setValue("PIN", std::string(cmd->arg3));
- break;
- case MDGD_REQ_EJECT_DEVICE:
- rep.setValue("name", std::string(cmd->arg1));
- rep.setValue("id", std::string(cmd->arg2));
- break;
- case MDGD_REQ_CHANNEL_LIST:
- break;
- default:
- LOG_ERR("Invalid command %d", cmd->command);
- return -1;
- }
-
- ret = resource->post(rep, QueryParamsMap(),
- std::bind (&__send_data_finish, std::placeholders::_1,
- std::placeholders::_2, std::placeholders::_3, cmd));
-
- } catch (OCException &e) {
- LOG_ERR("Failed to send data %s", e.what());
- ret = e.code();
- }
-
- LOG_DEBUG("Send Data : %s", get_error_message(ret));
return ret;
}
-
#define MAXBUF 1024
/* FILE Receive in thread */
-static gpointer file_receive_thread_func(gpointer user_data)
+static gpointer __file_receive_thread_func(gpointer user_data)
{
LOG_BEGIN();
int server_sockfd;
int client_sockfd;
int fd;
- struct sockaddr_in6 serveraddr, clientaddr;
- char client_ipaddr[INET6_ADDRSTRLEN];
+ struct sockaddr_in serveraddr, clientaddr;
+ char client_ipaddr[INET_ADDRSTRLEN];
int read_len, file_read_len;
socklen_t client_len;
struct linger ling;
- char *file_path = (char *)user_data;
+ mdgd_receive_file_t *receive_file = (mdgd_receive_file_t *)user_data;
- if (file_path == NULL) {
- LOG_ERR("file path is NULL");
+ if (receive_file == NULL) {
+ LOG_ERR("receive_file is NULL");
+ goto RECEIVE_THREAD_EXIT;
+ }
+ if (receive_file->file_path == NULL) {
+ LOG_ERR("receive_file->file_path is NULL");
+ goto RECEIVE_THREAD_EXIT;
+ }
+ if (receive_file->device_id == NULL) {
+ LOG_ERR("receive_file->device_id is NULL");
goto RECEIVE_THREAD_EXIT;
}
- LOG_DEBUG("file path : %s", file_path);
- fd = open(file_path, O_WRONLY | O_CREAT | O_EXCL, 0700);
+ LOG_DEBUG("file path : %s", receive_file->file_path);
+
+ fd = open(receive_file->file_path, O_WRONLY | O_CREAT | O_EXCL, 0700);
if(!fd || errno == EEXIST) {
LOG_ERR("file open error : %s", strerror(errno));
goto RECEIVE_THREAD_EXIT;
client_len = sizeof(clientaddr);
- server_sockfd = socket(AF_INET6, SOCK_STREAM, 0);
+ server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(server_sockfd == -1) {
LOG_ERR("socket error : %s", strerror(errno));
goto RECEIVE_THREAD_EXIT;
setsockopt(server_sockfd, SOL_SOCKET, SO_LINGER, &ling, sizeof(ling));
bzero(&serveraddr, sizeof(serveraddr));
- serveraddr.sin6_family = AF_INET6;
- serveraddr.sin6_addr = in6addr_any;
- serveraddr.sin6_port = htons(PORT);
- serveraddr.sin6_flowinfo = 0;
- serveraddr.sin6_scope_id = if_nametoindex("wlan0");
+ serveraddr.sin_family = AF_INET;
+ serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
+ serveraddr.sin_port = htons(PORT);
if (bind(server_sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0) {
LOG_ERR("bind error : %s", strerror(errno));
}
client_sockfd = accept(server_sockfd, (struct sockaddr *)&clientaddr, &client_len);
- inet_ntop(AF_INET6, &clientaddr.sin6_addr, client_ipaddr, sizeof(client_ipaddr));
+ inet_ntop(AF_INET, &clientaddr.sin_addr.s_addr, client_ipaddr, sizeof(client_ipaddr));
LOG_DEBUG("Accepted IP : %s", client_ipaddr);
char buf[MAXBUF] = {0,};
file_read_len = read(client_sockfd, buf, MAXBUF);
write(fd, buf, file_read_len);
- if(file_read_len == EOF | file_read_len == 0) {
+ if (file_read_len == EOF | file_read_len == 0) {
LOG_DEBUG("Receive file successful");
- //send event to client
+ mdgd_group_notify_event(NULL, MDGD_EVENT_RECEIVE_FILE, MDGD_ERROR_NONE, receive_file);
+
break;
}
}
if (!requestRep.getValue("file_path", file_path))
LOG_ERR("CMD not found in representation");
+ mdgd_receive_file_t *receive_file = g_new0(mdgd_receive_file_t, 1);
+ receive_file->file_path = g_strdup(file_path.c_str());
+ receive_file->device_id = g_strdup(requester_id.c_str());
+
g_thread_try_new("file_receive_thread",
- file_receive_thread_func, g_strdup(file_path.c_str()), NULL);
+ __file_receive_thread_func, receive_file, NULL);
break;
}
val = g_variant_lookup_value(device_info, "port", G_VARIANT_TYPE_UINT16);
int port = g_variant_get_uint16(val);
LOG_DEBUG("port = %d", port);
- device->port = port;
val = g_variant_lookup_value(device_info, "addr", G_VARIANT_TYPE_STRING);
const char *addr = g_variant_get_string(val, &len);
LOG_DEBUG("addr = %s", addr);
- device->addr = g_strdup(addr);
- val = g_variant_lookup_value(device_info, "connType", G_VARIANT_TYPE_UINT32);
- int connType = g_variant_get_uint32(val);
- LOG_DEBUG("connType = %d", connType);
- device->conn_type = connType;
+ char *host_addr = mdgd_addr2host(addr, port, false);
- val = g_variant_lookup_value(device_info, "securePort", G_VARIANT_TYPE_UINT16);
- int securePort = g_variant_get_uint16(val);
- LOG_DEBUG("securePort = %d", securePort);
- device->secure_port = securePort;
+ val = g_variant_lookup_value(device_info, "connType", G_VARIANT_TYPE_UINT32);
+ int conn_type = g_variant_get_uint32(val);
+ LOG_DEBUG("connType = %d", conn_type);
if (!strncmp(signal_name, "disc_mot_enb_devs_done", strlen(signal_name))) {
device->is_invited = false;
cmd->user_data = (void *)device;
- mdgd_iot_get_device_description(cmd);
+ mdgd_iot_get_device_description(cmd, host_addr, conn_type);
}
} else if (0 == g_strcmp0(signal_name, "pair_done") ||
0 == g_strcmp0(signal_name, "unpair_done")) {
g_free(cmd->uuid);
cmd->uuid = NULL;
}
- if (cmd->host) {
- g_free(cmd->host);
- cmd->host = NULL;
- }
if (cmd->arg1) {
g_free(cmd->arg1);
cmd->arg1 = NULL;
g_variant_builder_add(builder, "{sv}", "DeviceID",
g_variant_new_string(group->device_id));
- g_variant_builder_add(builder, "{sv}", "HostAddr",
- g_variant_new_string(group->host_addr));
g_variant_builder_add(builder, "{sv}", "GroupName",
g_variant_new_string(group->group_name));
g_variant_builder_add(builder, "{sv}", "Type",
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",
return va;
}
+GVariant *mdgd_create_variant_receive_file(mdgd_receive_file_t *receive_file)
+{
+ GVariant *va;
+
+ GVariantBuilder *builder;
+
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+
+ g_variant_builder_add(builder, "{sv}", "DeviceID",
+ g_variant_new_string(receive_file->device_id));
+ g_variant_builder_add(builder, "{sv}", "FilePath",
+ g_variant_new_string(receive_file->file_path));
+
+ va = g_variant_builder_end(builder);
+
+ g_variant_builder_unref(builder);
+
+ return va;
+}
+
GVariant *mdgd_create_variant_channel(mdgd_channel_t *channel)
{
GVariant *va;
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",
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->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);
return MA_ERROR_NONE;
}
+int pairwise_ret;
+
static void _resources_pairwise_cb(void* ctx, int nOfRes, OCProvisionResult_t* arr,
bool has_error)
{
if (!has_error) {
MA_LOGD("Provision pairwise SUCCEEDED");
+ pairwise_ret = MA_ERROR_NONE;
} else {
MA_LOGD("Provision pairwise FAILED ");
ma_print_result_list((const OCProvisionResult_t*) arr, nOfRes);
}
g_mutex_lock(&g_client->iotivity_mutex);
+ pairwise_ret = MA_ERROR_OPERATION_FAILED;
ret = OCProvisionPairwiseDevices((void*) g_client, SYMMETRIC_PAIR_WISE_KEY,
OWNER_PSK_LENGTH_256, target_dev_1, acl_1,
target_dev_2, acl_2, _resources_pairwise_cb);
/* Notify pair result */
if (con) {
- con->ret = ret;
+ con->ret = pairwise_ret;
__notify_result(con);
}
if (uuid_1)
projects / platform / core / connectivity / mdg-manager.git / commitdiff