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 *channel_id,
- unsigned char *data, int len);
+ unsigned char *data, int len, int *msg_id);
+int mdgd_group_send_response(char *sender, char *uuid, char *channel_id,
+ int msg_id, unsigned char *data, int len);
/* Group Request to remote */
int mdgd_group_request(mdgd_request_type_e type, char *sender, char *uuid,
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_get_device_description(mdgd_command_t *cmd, char *host_addr, int conn_type);
+int mdgd_iot_send_response(char *sender, char *uuid, char *channel_id,
+ int msg_id, unsigned char *data, int len, bool timeout);
int mdgd_iot_deinitialize();
#ifdef __cplusplus
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 */
+ MDGD_ERROR_NETWORK_UNREACHABLE = TIZEN_ERROR_MDG | 0x09,
} mdg_error_e;
typedef enum {
MDGD_REQ_CHANNEL_LIST, /**< Channel List */
MDGD_REQ_SEND_DATA, /**< Send data */
MDGD_REQ_SEND_FILE, /**< Send File */
+ MDGD_REQ_EVENT_INVITED,
+ MDGD_REQ_EVENT_EJECTED,
} mdgd_request_type_e;
typedef enum {
MDGD_EVENT_RECEIVE_FILE = 10,
MDGD_EVENT_SEND_FILE_PROGRESS,
MDGD_EVENT_SEND_FILE_FINISH,
+ MDGD_EVENT_INVITED,
+ MDGD_EVENT_EJECTED,
} mdgd_event_type_e;
typedef struct {
} mdgd_channel_t;
typedef struct {
+ char *sender;
char *device_id;
char *channel_id;
- unsigned char *data;
- int data_length;
+ int msg_id;
+ int tid;
+ char *data;
+ int data_len;
+ void *user_data;
} mdgd_data_t;
typedef struct {
GMainLoop *main_loop;
GHashTable *channel;
+ GSList *receive_data;
+ GSList *send_data;
int ref_count;
char *device_uuid;
mdgd_device_t *device;
#endif
int conn_type;
void *user_data;
+ int msg_id;
} mdgd_command_t;
typedef struct {
#include <octypes.h>
#include <pmtypes.h>
#include <mdgd_log.h>
+#include <base64.h>
char *mdgd_addr2host(char *addr, int port, bool is_secure);
int mdgd_uuid_to_str(const OicUuid_t* uuid, char** strUuid);
long send_size, long total_size, int percent);
GVariant *mdgd_create_variant_dummy();
mdgd_device_t *mdg_get_device_from_variant(GVariant *va);
+int mdgd_util_get_msg_id();
+
+void mdgd_util_data_encode(const char *data, int data_len,
+ char **encoded_data, int *encoded_len);
+
+void mdgd_util_data_decode(const char *data, int data_len,
+ char **decoded_data, int *decoded_len);
#ifdef __cplusplus
<arg type="s" name="channel_id" direction="in"/>
<arg type="(iay)" name="data" direction="in"/>
<arg type="i" name="result" direction="out" />
+ <arg type="i" name="msg_id" direction="out" />
+ </method>
+ <method name="SendResponse">
+ <arg type="s" name="uuid" direction="in" />
+ <arg type="s" name="channel_id" direction="in"/>
+ <arg type="i" name="msg_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" />
int len;
unsigned char *data;
GVariantIter *iter;
+ int msg_id;
LOG_BEGIN();
data = g_try_malloc0(len + 1);
if (NULL == data) {
- group_complete_send_data(group, invocation, -1);
+ group_complete_send_data(group, invocation, -1, NULL);
LOG_ERR("Failed to allocate memory");
return TRUE;
}
g_variant_iter_free(iter);
- ret = mdgd_group_send_data(sender, uuid, channel_id, data, len);
+ ret = mdgd_group_send_data(sender, uuid, channel_id, data, len, &msg_id);
- group_complete_send_data(group, invocation, ret);
+ group_complete_send_data(group, invocation, ret, msg_id);
+
+ g_free(data);
+
+ LOG_END();
+
+ return ret;
+}
+
+gboolean group_send_response(Group *group, GDBusMethodInvocation *invocation,
+ gchar *uuid, gchar *channel_id, gint msg_id, GVariant *params, gpointer user_data)
+{
+ int ret = MDGD_ERROR_NONE;
+ const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
+
+ int length = 0;
+ int len;
+ unsigned char *data;
+ GVariantIter *iter;
+
+ LOG_BEGIN();
+
+ g_variant_get(params, "(iay)", &len, &iter);
+
+ data = g_try_malloc0(len + 1);
+ if (NULL == data) {
+ group_complete_send_response(group, invocation, -1);
+ LOG_ERR("Failed to allocate memory");
+ return TRUE;
+ }
+
+ while (g_variant_iter_loop(iter, "y", &data[length]))
+ length += 1;
+
+ g_variant_iter_free(iter);
+
+ ret = mdgd_group_send_response(sender, uuid, channel_id, msg_id, data, len);
+
+ group_complete_send_response(group, invocation, ret);
g_free(data);
NULL);
g_signal_connect(group_skeleton,
+ "handle-send-response",
+ G_CALLBACK(group_send_response),
+ NULL);
+
+ g_signal_connect(group_skeleton,
"handle-send-file",
G_CALLBACK(group_send_file),
NULL);
}
int mdgd_group_send_data(char *sender, char *uuid, char *channel_id,
- unsigned char *data, int len)
+ unsigned char *data, int len, int *msg_id)
{
int ret;
return ret;
}
+ *msg_id = mdgd_util_get_msg_id();
+
cmd->resource_type = MDGD_RESOURCE_TYPE_DATA;
cmd->type = MDGD_REQ_SEND_DATA;
cmd->uuid = g_strdup(uuid);
cmd->sender = g_strdup(sender);
cmd->arg1 = g_strdup(channel_id);
-#ifdef SUPPORT_BASE64_ENCODING
+ cmd->msg_id = *msg_id;
+
cmd->data = g_try_malloc0(len + 1);
if (NULL == cmd->data) {
ret = MDGD_ERROR_OUT_OF_MEMORY;
memcpy(cmd->data, data, len);
cmd->data_len = len;
-#else
- cmd->arg2 = g_try_malloc0(len + 1);
- if (NULL == cmd->arg2) {
- ret = MDGD_ERROR_OUT_OF_MEMORY;
- LOG_ERR("Send Data Fail to uuid = %s error=%s",
- cmd->uuid, mdgd_log_get_error_string(ret));
- return ret;
- }
-
- memcpy(cmd->arg2, data, len);
- cmd->arg2[len] = '\0';
-#endif
ret = mdgd_iot_discovery_resource(cmd->resource_type, cmd);
return ret;
}
+int mdgd_group_send_response(char *sender, char *uuid, char *channel_id,
+ int msg_id, unsigned char *data, int len)
+{
+ int ret;
+
+ ret = mdgd_iot_send_response(sender, uuid, channel_id, msg_id, data, len, false);
+
+ return ret;
+}
int mdgd_group_request(mdgd_request_type_e type, char *sender, char *uuid,
char *arg1, char *arg2, char *arg3, void *user_data)
case MDGD_EVENT_DEVICE_FIND_FINISH:
case MDGD_EVENT_INVITE_DEVICE_FINISH:
case MDGD_EVENT_EJECT_DEVICE_FINISH:
- case MDGD_EVENT_SEND_DATA_FINISH:
va = mdgd_create_variant_dummy();
break;
case MDGD_EVENT_REQ_CHANNEL_LIST_FINISH:
va = mdgd_create_variant_channel((mdgd_channel_t *)user_data);
break;
case MDGD_EVENT_RECEIVE_DATA:
+ case MDGD_EVENT_SEND_DATA_FINISH:
va = mdgd_create_variant_data((mdgd_data_t *)user_data);
break;
case MDGD_EVENT_RECEIVE_FILE:
#include <tzplatform_config.h>
#include <utlist.h>
-#include <base64.h>
#include <sys/utsname.h>
#include <octypes.h>
OC::ServiceType::InProc,
OC::ModeType::Both,
(OCTransportAdapter)(OCTransportAdapter::OC_ADAPTER_IP),
- OC::QualityOfService::HighQos,
+ OC::QualityOfService::LowQos,
&ps
};
#include <tzplatform_config.h>
#include <utlist.h>
-#include <base64.h>
#include <sys/utsname.h>
#include <octypes.h>
LOG_END();
}
+static gboolean _send_data_timeout_cb(gpointer data)
+{
+ int ret = MDGD_ERROR_NONE;
+ mdgd_data_t *send_data = (mdgd_data_t *)data;
+
+ LOG_BEGIN();
+
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+ mdgd_context_mutex_lock();
+
+ LOG_DEBUG("Timeout : Network Unreachable");
+
+ GSList *l;
+ for (l = mdgd_ctx->send_data; l != NULL; l = l->next) {
+ mdgd_data_t *tmp_data_t = (mdgd_data_t *)l->data;
+ if (tmp_data_t->msg_id == send_data->msg_id) {
+ mdgd_group_notify_event(tmp_data_t->sender, MDGD_EVENT_SEND_DATA_FINISH,
+ MDGD_ERROR_NETWORK_UNREACHABLE, tmp_data_t);
+
+ mdgd_ctx->send_data = g_slist_remove_link(mdgd_ctx->send_data, l);
+ break;
+ }
+ }
+
+ mdgd_context_mutex_unlock();
+
+ LOG_END();
+
+ return false;
+}
+
+static void __send_data_finish(const HeaderOptions&,
+ const OCRepresentation& rep, const int eCode,
+ void *user_data)
+{
+ int ret = MDGD_ERROR_NONE;
+
+ std::string channel_id, data;
+ int msg_id;
+ char* decoded_data;
+ int decoded_len, data_len = 0;
+ bool time_out;
+ mdgd_data_t *send_data = (mdgd_data_t *)user_data;
+
+ LOG_BEGIN();
+
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+ mdgd_context_mutex_lock();
+
+ if (!rep.getValue("ChannelID", channel_id))
+ LOG_ERR("channel id not found");
+
+ if (!rep.getValue("MsgID", msg_id))
+ LOG_ERR("mdg id not found");
+
+ if (!rep.getValue("Timeout", time_out))
+ LOG_ERR("timeout not found");
+
+ GSList *l;
+ for (l = mdgd_ctx->send_data; l != NULL; l = l->next) {
+ mdgd_data_t *tmp_data_t = (mdgd_data_t *)l->data;
+ if (tmp_data_t->msg_id == msg_id) {
+ if (time_out == false) {
+ if (!rep.getValue("Data", data))
+ LOG_ERR("data not found");
+
+ if (!rep.getValue("DataLen", data_len))
+ LOG_ERR("data_len not found");
+
+ mdgd_util_data_decode(data.c_str(), data_len, &decoded_data, &decoded_len);
+
+ tmp_data_t->data = decoded_data;
+ tmp_data_t->data_len = decoded_len;
+
+ LOG_DEBUG("Send data callback : data : %s", decoded_data);
+ } else {
+ ret = MDGD_ERROR_NONE;
+ LOG_DEBUG("Send data callback : Timeout occurs");
+ }
+
+ g_source_remove(tmp_data_t->tid);
+
+ mdgd_group_notify_event(tmp_data_t->sender, MDGD_EVENT_SEND_DATA_FINISH, ret, tmp_data_t);
+
+ mdgd_ctx->send_data = g_slist_remove_link(mdgd_ctx->send_data, l);
+ break;
+ }
+ }
+
+ mdgd_context_mutex_unlock();
+
+ LOG_END();
+}
+
static void __request_finish(const HeaderOptions&,
const OCRepresentation& rep, const int eCode,
void *user_data)
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);
char *resource_type = NULL;
mdgd_group_type_e group_type;
std::string resourceURI;
+ OCRepresentation rep;
mdgd_check_null_ret_error("user_data", user_data, TRUE);
mdgd_command_t *cmd = (mdgd_command_t *)user_data;
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
LOG_BEGIN();
try {
if (resource) {
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
-
- LOG_DEBUG("URI [%s], Host [%s], Device ID [%s]",
- resource->uri().c_str(), resource->host().c_str(), resource->sid().c_str());
-
for(auto &resourceTypes : resource->getResourceTypes()) {
- LOG_DEBUG("Resource Type [%s]", resourceTypes.c_str());
if (resource_type == NULL)
resource_type = g_strdup(resourceTypes.c_str());
}
+ LOG_DEBUG("URI [%s], Host [%s], Device ID [%s], Resource [%s]",
+ resource->uri().c_str(), resource->host().c_str(), resource->sid().c_str(), resource_type);
+
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));
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_DEVICE)) == 0 &&
+ g_strcmp0(cmd->uuid, resource->sid().c_str()) == 0) {
+ rep.setValue("CMD", cmd->type);
+ rep.setValue("DeviceID", std::string(mdgd_ctx->device_uuid));
+ if (cmd->type == MDGD_REQ_EVENT_INVITED) {
+ rep.setValue("Event", std::string("Invited"));
+ } else if (cmd->type == MDGD_REQ_EVENT_EJECTED) {
+ rep.setValue("Event", std::string("Ejected"));
+ }
+
+ /*
+ resource->put(rep, QueryParamsMap(), std::bind (&__send_data_finish,
+ std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, send_data));
+ */
+ } 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);
+ rep.setValue("DeviceID", std::string(mdgd_ctx->device_uuid));
- 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());
- cmd->conn_type = resource->connectivityType();
-
- if (cmd->conn_type & CT_IP_USE_V6) {
- rep.setValue("conn_type", std::string("V6"));
- LOG_DEBUG("The connection type is IPv6");
- } else {
- rep.setValue("conn_type", std::string("V4"));
- LOG_DEBUG("The connection type is IPv4");
- }
+ if (cmd->type == MDGD_REQ_SEND_DATA) {
+ char *encoded_data = NULL;
+ int encoded_len = 0;
+
+ rep.setValue("ChannelID", std::string(cmd->arg1));
+ rep.setValue("MsgID", cmd->msg_id);
- 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;
+ mdgd_util_data_encode((const char *)cmd->data, cmd->data_len, &encoded_data, &encoded_len);
+
+ rep.setValue("Data", std::string(encoded_data));
+ rep.setValue("DataLen", encoded_len);
+
+ /* create structure for store the msgID, channel ID */
+ mdgd_data_t *send_data = g_new0(mdgd_data_t, 1);
+ send_data->sender = g_strdup(cmd->sender);
+ send_data->device_id = g_strdup(cmd->uuid);
+ send_data->channel_id = g_strdup(cmd->arg1);
+ send_data->msg_id = cmd->msg_id;
+ send_data->tid = g_timeout_add_seconds(7, _send_data_timeout_cb, send_data);
+
+ mdgd_context_mutex_lock();
+ mdgd_ctx->send_data = g_slist_prepend(mdgd_ctx->send_data, send_data);
+ mdgd_context_mutex_unlock();
+
+ resource->post(rep, QueryParamsMap(), std::bind (&__send_data_finish,
+ std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, send_data));
+ } else {
+ switch (cmd->type) {
+ case MDGD_REQ_SEND_FILE:
+ rep.setValue("FilePath", std::string(cmd->arg1));
+ cmd->addr = g_strdup(resource->host().c_str());
+ cmd->conn_type = resource->connectivityType();
+
+ if (cmd->conn_type & CT_IP_USE_V6) {
+ rep.setValue("ConnType", std::string("V6"));
+ LOG_DEBUG("The connection type is IPv6");
+ } else {
+ rep.setValue("ConnType", std::string("V4"));
+ LOG_DEBUG("The connection type is IPv4");
+ }
+
+ break;
+ case MDGD_REQ_CREATE_GROUP:
+ rep.setValue("GroupName", std::string(cmd->arg1));
+ break;
+ case MDGD_REQ_INVITE_DEVICE:
+ rep.setValue("GroupName", 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("GroupName", 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;
}
- 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));
+ resource->post(rep, QueryParamsMap(), std::bind (&__request_finish,
+ std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, cmd));
+ }
}
}
else {
#include <tzplatform_config.h>
#include <utlist.h>
-#include <base64.h>
#include <sys/utsname.h>
#include <octypes.h>
#define PORT 8675
#define MAXBUF 1024
+typedef struct {
+ std::shared_ptr<OC::OCResourceResponse> pResponse;
+} OCResourceResponse_t;
+
/* FILE Receive in thread */
static gpointer __file_receive_thread_func(gpointer user_data)
{
struct sockaddr_in6 serveraddr_v6, clientaddr_v6;
char client_ipaddr[INET_ADDRSTRLEN];
char client_ipaddr_v6[INET6_ADDRSTRLEN];
- int read_len, file_read_len;
+ int file_read_len;
socklen_t client_len;
struct linger ling;
mdgd_receive_file_t *receive_file = (mdgd_receive_file_t *)user_data;
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");
mdgd_group_notify_event(NULL, MDGD_EVENT_RECEIVE_FILE, MDGD_ERROR_NONE, receive_file);
return NULL;
}
+int mdgd_iot_send_response(char *sender, char *uuid, char *channel_id,
+ int msg_id, unsigned char *data, int data_len, bool timeout)
+{
+ int ret = MDGD_ERROR_NO_DATA;
+
+ LOG_BEGIN();
+
+ mdgd_context_t *mdg_ctx = mdgd_context_get_context();
+
+ mdgd_context_mutex_lock();
+
+ GSList *l;
+ for (l = mdg_ctx->receive_data; l != NULL; l = l->next) {
+ mdgd_data_t *tmp_data_t = (mdgd_data_t *)l->data;
+ if ((tmp_data_t->msg_id == msg_id) &&
+ g_strcmp0(tmp_data_t->sender, sender) == 0 &&
+ g_strcmp0(tmp_data_t->device_id, uuid) == 0) {
+
+ OCResourceResponse_t *response = (OCResourceResponse_t *)tmp_data_t->user_data;
+ std::shared_ptr<OC::OCResourceResponse> pResponse = response->pResponse;
+ OCRepresentation responseRep;
+
+ responseRep.setValue("ChannelID", std::string(tmp_data_t->channel_id));
+ responseRep.setValue("MsgID", tmp_data_t->msg_id);
+
+ if (timeout == false) {
+ char *encoded_data;
+ int encoded_len;
+
+ LOG_DEBUG("Response to Sender");
+
+ mdgd_util_data_encode((const char *)data, data_len, &encoded_data, &encoded_len);
+
+ responseRep.setValue("Data", std::string(encoded_data));
+ responseRep.setValue("DataLen", encoded_len);
+ responseRep.setValue("Timeout", false);
+
+ g_source_remove(tmp_data_t->tid);
+ } else {
+ LOG_DEBUG("Timeout occurs");
+ responseRep.setValue("Timeout", true);
+ }
+
+ pResponse->setResourceRepresentation(responseRep, DEFAULT_INTERFACE);
+
+ OCPlatform::sendResponse(pResponse);
+ ret = MDGD_ERROR_NONE;
+
+ mdg_ctx->receive_data = g_slist_remove_link(mdg_ctx->receive_data, l);
+ break;
+ }
+ }
+
+ mdgd_context_mutex_unlock();
+
+ LOG_END();
+
+ return ret;
+}
+
+static gboolean _receive_data_timeout_cb(gpointer data)
+{
+ int ret = MDGD_ERROR_NONE;
+ mdgd_data_t *receive_data = (mdgd_data_t *)data;
+
+ LOG_BEGIN();
+
+ ret = mdgd_iot_send_response(receive_data->sender, receive_data->device_id, receive_data->channel_id,
+ receive_data->msg_id, NULL, 0, true);
+ if (ret != MDGD_ERROR_NONE)
+ LOG_ERR("There is not message");
+
+ LOG_END();
+
+ return false;
+}
+
OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> request)
{
LOG_BEGIN();
} else {
LOG_ERR("Unknown Resource URI");
}
+
+ pResponse->setRequestHandle(request->getRequestHandle());
+ pResponse->setResourceHandle(request->getResourceHandle());
+ pResponse->setErrorCode(200);
+ pResponse->setResponseResult(OC_EH_OK);
+ pResponse->setResourceRepresentation(responseRep, DEFAULT_INTERFACE);
+
+ LOG_DEBUG("Send response : %d", OC_EH_OK);
+ OCPlatform::sendResponse(pResponse);
} else if (requestType == "POST") { /* Request Operation */
- unsigned char *arg = NULL;
- int arg_len = 0;
- int result = MDGD_ERROR_NONE;
- int cmd;
- std::string requester_id, group_name, uuid, data, data_length, channel_id, file_path, conn_type;
-#ifdef SUPPORT_BASE64_ENCODING
- int data_len;
- size_t outSize;
- uint8_t *out;
- uint32_t len = 0;
-#endif
try {
+ int result = MDGD_ERROR_NONE;
+ int cmd;
+ std::string requester_id;
+
if (!requestRep.getValue("CMD", cmd))
LOG_ERR("CMD not found in representation");
- else
- LOG_DEBUG("Command received %d", cmd);
- if (!requestRep.getValue("device_id", requester_id))
+ if (!requestRep.getValue("DeviceID", requester_id))
LOG_ERR("device_id not found in representation");
- else
- LOG_DEBUG("device_id received %s", requester_id.c_str());
-
- switch(cmd) {
- case MDGD_REQ_SEND_FILE:
- {
- LOG_DEBUG("Receive File");
- if (!requestRep.getValue("file_path", file_path))
- LOG_ERR("CMD not found in representation");
- if (!requestRep.getValue("conn_type", conn_type))
- LOG_ERR("conn_type 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());
- receive_file->conn_type = g_strdup(conn_type.c_str());
-
- g_thread_try_new("file_receive_thread",
- __file_receive_thread_func, receive_file, NULL);
-
- break;
- }
- case MDGD_REQ_SEND_DATA:
- {
+ if (cmd == MDGD_REQ_SEND_DATA) {
LOG_DEBUG("Receive Data");
- if (!requestRep.getValue("channel_id", channel_id))
- LOG_ERR("channel id not found");
-
- char *sender = (char *)g_hash_table_lookup(mdgd_ctx->channel, channel_id.c_str());
-
-#ifdef SUPPORT_BASE64_ENCODING
- if (!requestRep.getValue("data", data))
- LOG_ERR("data not found");
- if (!requestRep.getValue("data_length", data_length))
- LOG_ERR("data length not found");
-
- /*
- * BASE64 encoding/decoding system use '=' as padding byte
- * But, query parameter does not allow use '=' character.Basically,
- * So, in order to use BASE64 as query parameters, we need additioinal length param
- * such as 'len=xx'
- */
- data_len = atoi(data_length.c_str());
-
- outSize = B64DECODE_OUT_SAFESIZE(data_len + 1);
- out = (uint8_t *)g_try_malloc0(outSize);
- if (NULL == out) {
- LOG_ERR("Can't allocate memory for base64 str");
- return OC_EH_OK;
- }
-
- if (B64_OK != b64Decode(data.c_str(), data_len, out,
- outSize, &len)) {
- LOG_ERR("Base64 decoding failed.");
- g_free(out);
- return OC_EH_OK;
- }
+ int data_len, decoded_len = 0;
+ char *decoded_data = NULL;
+ std::string channel_id, data;
+ int msg_id;
- arg = (unsigned char *) g_try_malloc0(len);
- memcpy(arg, out, len);
- arg_len = len;
+ if (!requestRep.getValue("ChannelID", channel_id))
+ LOG_ERR("channel_id not found");
- g_free(out);
+ if (!requestRep.getValue("MsgID", msg_id))
+ LOG_ERR("msg_id not found");
- LOG_DEBUG("Successfully decoded from base64 : %s", arg);
-#else
- if (!requestRep.getValue("data", data))
+ if (!requestRep.getValue("Data", data))
LOG_ERR("data not found");
- LOG_DEBUG("Receive Data = %s", data.c_str());
- arg = (unsigned char *)g_strdup(data.c_str());
- arg_len = strlen(data.c_str());
-#endif
- mdgd_data_t *data_t = g_new0(mdgd_data_t, 1);
- data_t->device_id = g_strdup(requester_id.c_str());
- data_t->data = arg;
- data_t->data_length = arg_len;
- data_t->channel_id = g_strdup(channel_id.c_str());
+ if (!requestRep.getValue("DataLen", data_len))
+ LOG_ERR("data_len not found");
- mdgd_group_notify_event(sender, MDGD_EVENT_RECEIVE_DATA, result, data_t);
+ mdgd_util_data_decode(data.c_str(), data_len, &decoded_data, &decoded_len);
- break;
- }
- case MDGD_REQ_CREATE_GROUP:
- LOG_DEBUG("Request create group");
-
- result = MDGD_ERROR_NONE;
+ char *sender = (char *)g_hash_table_lookup(mdgd_ctx->channel, channel_id.c_str());
- if (requestRep.getValue("name", group_name)) {
- LOG_DEBUG("group_name : %s", group_name.c_str());
- result = mdgd_group_create(group_name.c_str());
+ mdgd_data_t *receive_data = g_new0(mdgd_data_t, 1);
+ receive_data->sender = g_strdup(sender);
+ receive_data->device_id = g_strdup(requester_id.c_str());
+ receive_data->data = decoded_data;
+ receive_data->data_len = decoded_len;
+ receive_data->channel_id = g_strdup(channel_id.c_str());
+ receive_data->msg_id = msg_id;
+ receive_data->tid = g_timeout_add_seconds(5, _receive_data_timeout_cb, receive_data);
+
+ OCResourceResponse_t *response = g_new0(OCResourceResponse_t, 1);
+ pResponse->setRequestHandle(request->getRequestHandle());
+ pResponse->setResourceHandle(request->getResourceHandle());
+ pResponse->setErrorCode(200);
+ pResponse->setResponseResult(OC_EH_OK);
+ response->pResponse = pResponse;
+ receive_data->user_data = response;
+
+ mdgd_context_mutex_lock();
+ mdgd_ctx->receive_data = g_slist_prepend(mdgd_ctx->receive_data, receive_data);
+ mdgd_context_mutex_unlock();
+
+ mdgd_group_notify_event(sender, MDGD_EVENT_RECEIVE_DATA, result, receive_data);
+ } else {
+ std::string group_name, uuid;
+
+ switch(cmd) {
+ case MDGD_REQ_SEND_FILE:
+ {
+ std::string file_path, conn_type;
+ LOG_DEBUG("Receive File");
+ if (!requestRep.getValue("FilePath", file_path))
+ LOG_ERR("CMD not found in representation");
+
+ if (!requestRep.getValue("ConnType", conn_type))
+ LOG_ERR("conn_type 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());
+ receive_file->conn_type = g_strdup(conn_type.c_str());
+
+ g_thread_try_new("file_receive_thread",
+ __file_receive_thread_func, receive_file, NULL);
+
+ break;
+ }
+ case MDGD_REQ_CREATE_GROUP:
+ LOG_DEBUG("Request create group");
+
+ result = MDGD_ERROR_NONE;
+
+ if (requestRep.getValue("GroupName", group_name)) {
+ LOG_DEBUG("group_name : %s", group_name.c_str());
+ result = mdgd_group_create(group_name.c_str());
+ }
+ break;
+ case MDGD_REQ_INVITE_DEVICE:
+ LOG_DEBUG("Request invite device");
+
+ if (!requestRep.getValue("GroupName", group_name))
+ LOG_ERR("Group name not found");
+ if (!requestRep.getValue("ID", uuid))
+ LOG_ERR("UUID not found");
+
+ 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");
+
+ if (!requestRep.getValue("GroupName", group_name))
+ LOG_ERR("Group name not found");
+ if (!requestRep.getValue("ID", uuid))
+ LOG_ERR("UUID not found");
+
+ LOG_DEBUG("group name : %s Self UUID : %s Target UUID : %s",
+ group_name.c_str(),mdgd_ctx->device_uuid, uuid.c_str());
+
+ result = mdgd_group_eject_device("tmp", group_name.c_str(),
+ uuid.c_str());
+ break;
+ case MDGD_REQ_CHANNEL_LIST:
+ LOG_DEBUG("Request channel list");
+ GHashTableIter iter;
+ char *key;
+
+ g_hash_table_iter_init(&iter, mdgd_ctx->channel);
+
+ while (g_hash_table_iter_next(&iter, (gpointer *)&key, NULL)) {
+ char *channel_id = g_strdup(key);
+ LOG_DEBUG("Channel ID : %s", channel_id);
+ responseRep.setValue(std::string(channel_id), "NONE");
+ }
+
+ break;
+ default:
+ LOG_ERR("Unknown request command %d", cmd);
+ break;
}
- break;
- case MDGD_REQ_INVITE_DEVICE:
- LOG_DEBUG("Request invite device");
-
- if (!requestRep.getValue("name", group_name))
- LOG_ERR("Group name not found");
- if (!requestRep.getValue("id", uuid))
- LOG_ERR("UUID not found");
- LOG_DEBUG("group name : %s, UUID : %s", group_name.c_str(),
- uuid.c_str());
+ pResponse->setRequestHandle(request->getRequestHandle());
+ pResponse->setResourceHandle(request->getResourceHandle());
+ pResponse->setErrorCode(200);
+ pResponse->setResponseResult(OC_EH_OK);
+ pResponse->setResourceRepresentation(responseRep, DEFAULT_INTERFACE);
- /* find device, and invite this device. */
+ LOG_DEBUG("Send response : %d", OC_EH_OK);
+ OCPlatform::sendResponse(pResponse);
+ }
+ } catch (std::exception& e) {
+ LOG_ERR("Exception occured %s", e.what());
+ }
+ }
/*
- 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");
-
- if (!requestRep.getValue("name", group_name))
- LOG_ERR("Group name not found");
- if (!requestRep.getValue("id", uuid))
- LOG_ERR("UUID not found");
+ else if (requestType == "PUT") {
+ if (strcmp(resourceUri.c_str(),
+ mdgd_resource_get_uri_prefix(MDGD_RESOURCE_TYPE_DEVICE)) == 0) {
- LOG_DEBUG("group name : %s Self UUID : %s Target UUID : %s",
- group_name.c_str(),mdgd_ctx->device_uuid,
- uuid.c_str());
+ if (!requestRep.getValue("CMD", cmd))
+ LOG_ERR("CMD not found in representation");
+ else
+ LOG_DEBUG("Command received %d", cmd);
- result = mdgd_group_eject_device("tmp", group_name.c_str(),
- uuid.c_str());
- break;
- case MDGD_REQ_CHANNEL_LIST:
- LOG_DEBUG("Request channel list");
- GHashTableIter iter;
- char *key;
+ if (!requestRep.getValue("device_id", requester_id))
+ LOG_ERR("device_id not found in representation");
+ else
+ LOG_DEBUG("device_id received %s", requester_id.c_str());
- g_hash_table_iter_init(&iter, mdgd_ctx->channel);
+ switch(cmd) {
+ case MDGD_REQ_EVENT_OCCUR:
+ LOG_DEBUG("Request event occur");
+ if (!requestRep.getValue("event", event))
+ LOG_ERR("Group name not found");
- while (g_hash_table_iter_next(&iter, (gpointer *)&key, NULL)) {
- char *channel_id = g_strdup(key);
- LOG_DEBUG("Channel ID : %s", channel_id);
- responseRep.setValue(std::string(channel_id), "NONE");
+ if (g_strcmp0(event.c_str(), "INVITED") == 0) {
+ mdgd_group_notify_event(NULL, MDGD_EVENT_INVITED, MDGD_ERROR_NONE, NULL);
+ } else if (g_strcmp0(event.c_str(), "EJECTED") == 0) {
+ mdgd_group_notify_event(NULL, MDGD_EVENT_EJECTED, MDGD_ERROR_NONE, NULL);
}
-
break;
default:
LOG_ERR("Unknown request command %d", cmd);
break;
}
+ }
- g_free(arg);
- } catch (std::exception& e) {
- LOG_ERR("Exception occured %s", e.what());
}
- } else {
+*/
+ else {
LOG_ERR("Invalid Request Type");
}
- pResponse->setRequestHandle(request->getRequestHandle());
- pResponse->setResourceHandle(request->getResourceHandle());
- pResponse->setErrorCode(200);
- pResponse->setResponseResult(OC_EH_OK);
- pResponse->setResourceRepresentation(responseRep, DEFAULT_INTERFACE);
- LOG_DEBUG("Send response : %d", OC_EH_OK);
- OCPlatform::sendResponse(pResponse);
}
LOG_END();
int ret;
LOG_DEBUG("COMP Manager start");
-
+/*
if (wait_mount_user() != 0) {
LOG_ERR("The user data space is not mounted");
goto EXIT;
}
-
+*/
//1. create & get context
ret = mdgd_context_create();
if (ret != MDGD_ERROR_NONE) {
*/
#include <mdgd_util.h>
+#include <time.h>
char *mdgd_addr2host(char *addr, int port, bool is_secure)
{
GVariant *va;
GVariantBuilder *builder;
- GVariantBuilder *bytearray_builder = NULL;
GVariant *params = NULL;
- bytearray_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
- for (int i = 0; i < data->data_length; i++)
- g_variant_builder_add(bytearray_builder, "(y)", data->data[i]);
-
- params = g_variant_new("a(y)", bytearray_builder);
builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
g_variant_new_string(data->device_id));
g_variant_builder_add(builder, "{sv}", "ChannelID",
g_variant_new_string(data->channel_id));
- g_variant_builder_add(builder, "{sv}", "Data",
- g_variant_new_variant(params));
- g_variant_builder_add(builder, "{sv}", "DataLength",
- g_variant_new_int32(data->data_length));
+ g_variant_builder_add(builder, "{sv}", "MsgID",
+ g_variant_new_int32(data->msg_id));
+
+ if (data->data_len > 0) {
+ GVariantBuilder *bytearray_builder = NULL;
+ bytearray_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
+ for (int i = 0; i < data->data_len; i++)
+ g_variant_builder_add(bytearray_builder, "(y)", data->data[i]);
+
+ params = g_variant_new("a(y)", bytearray_builder);
+ g_variant_builder_add(builder, "{sv}", "Data",
+ g_variant_new_variant(params));
+ g_variant_builder_add(builder, "{sv}", "DataLen",
+ g_variant_new_int32(data->data_len));
+ g_variant_builder_unref(bytearray_builder);
+ }
va = g_variant_builder_end(builder);
g_variant_builder_unref(builder);
- g_variant_builder_unref(bytearray_builder);
return va;
}
return device;
}
+int mdgd_util_get_msg_id()
+{
+ struct timespec tv;
+
+ clock_gettime(CLOCK_REALTIME, &tv);
+
+ return (int)tv.tv_nsec;
+}
+
+void mdgd_util_data_encode(const char *data, int data_len,
+ char **encoded_data, int *encoded_len)
+{
+#ifdef SUPPORT_BASE64_ENCODING
+ size_t out_size;
+ uint8_t *out;
+
+ out_size = B64ENCODE_OUT_SAFESIZE(data_len + 1);
+ out = (char *)g_malloc0(out_size);
+ if (NULL == out) {
+ LOG_ERR("Can't allocate memory for base64 str");
+ return;
+ }
+
+ if (B64_OK != b64Encode(data, data_len, out, out_size, encoded_len)) {
+ LOG_ERR("Base64 encoding failed.");
+ g_free(out);
+ return;
+ }
+
+ *encoded_data = (char *)g_try_malloc0(*encoded_len);
+ memcpy(*encoded_data, out, *encoded_len);
+
+ g_free(out);
+#else
+ *encoded_data = (char *)g_strdup(data);
+ *encoded_len = data_len;
+#endif
+
+ LOG_DEBUG("Successfully encoded %s", *encoded_data);
+}
+
+void mdgd_util_data_decode(const char *data, int data_len,
+ char **decoded_data, int *decoded_len)
+{
+#ifdef SUPPORT_BASE64_ENCODING
+ size_t out_size;
+ uint8_t *out;
+
+ out_size = B64DECODE_OUT_SAFESIZE(data_len + 1);
+ out = (uint8_t *)g_try_malloc0(out_size);
+ if (NULL == out) {
+ LOG_ERR("Can't allocate memory for base64 str");
+ return;
+ }
+
+ if (B64_OK != b64Decode(data, data_len, out, out_size, decoded_len)) {
+ LOG_ERR("Base64 decoding failed.");
+ g_free(out);
+ return;
+ }
+
+ *decoded_data = (char *)g_try_malloc0(*decoded_len);
+ memcpy(*decoded_data, out, *decoded_len);
+
+ g_free(out);
+#else
+ *decoded_data = (char *)g_strdup(data);
+ *decoded_len = data_len;
+#endif
+
+ LOG_DEBUG("Successfully decoded %s", *decoded_data);
+}
+
+
pairwise_ret = MA_ERROR_NONE;
} else {
MA_LOGD("Provision pairwise FAILED ");
+ pairwise_ret = nOfRes;
ma_print_result_list((const OCProvisionResult_t*) arr, nOfRes);
}
client->g_doneCB = true;
projects / platform / core / connectivity / mdg-manager.git / commitdiff