uuid
capi-base-common
capi-system-info
+ capi-network-wifi-manager
vconf
boost
gmock
sqlite3
+ storage
capi-system-system-settings)
IF (LINUX)
PKG_CHECK_MODULES(daemon_pkgs REQUIRED ${COMMON_DEPS})
BuildRequires: pkgconfig(gmock)
BuildRequires: pkgconfig(sqlite3)
BuildRequires: pkgconfig(capi-system-system-settings)
+BuildRequires: pkgconfig(storage)
Requires: capi-system-system-settings
%description
Multi Device Group Manager
[Unit]
Description=Multi Device Group Manager
-After=feedbckd.service
+Wants=wait-mount@opt-usr.service
+After=wait-mount@opt-usr.service
[Service]
Type=dbus
MDGD_REQ_INVITE_DEVICE, /**< Invite Device */
MDGD_REQ_EJECT_DEVICE, /**< Eject Device */
MDGD_REQ_CHANNEL_LIST, /**< Channel List */
+ MDGD_REQ_CHANNEL_OPEN, /**< Channel Open */
MDGD_REQ_SEND_DATA, /**< Send data */
- MDGD_REQ_SEND_FILE, /**< Send File */
MDGD_REQ_EVENT_INVITED,
MDGD_REQ_EVENT_EJECTED,
} mdgd_request_type_e;
MDGD_EVENT_REQUEST_FINISH,
MDGD_EVENT_SEND_DATA_FINISH,
MDGD_EVENT_REQ_CHANNEL_LIST_FINISH,
- MDGD_EVENT_RECEIVE_DATA,
- MDGD_EVENT_RECEIVE_FILE = 110,
- MDGD_EVENT_SEND_FILE_PROGRESS,
- MDGD_EVENT_SEND_FILE_FINISH,
+ MDGD_EVENT_REQ_CHANNEL_OPEN_FINISH,
+ MDGD_EVENT_RECEIVE_DATA = 110,
+ MDGD_EVENT_RECEIVE_OPEN_CHANNEL,
} mdgd_event_type_e;
typedef struct {
mdgd_device_type_e type; /**< Group type */
} mdgd_device_t;
-typedef struct {
- char *device_id; /**< Device Id */
- char *file_path;
- char *conn_type;
-} mdgd_receive_file_t;
-
typedef struct {
char *device_id;
char *channel_id;
+ char *remote_address;
} mdgd_channel_t;
typedef struct {
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);
-GVariant *mdgd_create_variant_progress(char *file_path, long send_size, long total_size, int percent);
GVariant *mdgd_create_variant_dummy();
mdgd_device_t *mdgd_get_device_from_variant(GVariant *va);
int mdgd_util_get_msg_id();
<arg type="s" name="preconfigured_pin" direction="in" />
<arg type="i" name="result" direction="out" />
</method>
+ <method name="RequestChannelOpen">
+ <arg type="s" name="uuid" direction="in" />
+ <arg type="s" name="channel_id" direction="in"/>
+ <arg type="i" name="result" direction="out" />
+ </method>
<!-- Signal (D-Bus) definitions -->
<signal name="Event">
<arg type="i" name="type" direction="out" />
return ret;
}
-gboolean group_send_file(Group *group, GDBusMethodInvocation *invocation,
- 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_request(MDGD_REQ_SEND_FILE, (char *)sender, uuid,
- file_path, NULL, NULL, NULL);
-
- group_complete_send_file(group, invocation, ret);
-
- LOG_END();
-
- return ret;
-}
-
gboolean group_request_create_group(Group *group, GDBusMethodInvocation *invocation, gchar *uuid, gchar *group_name, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
return TRUE;
}
+gboolean group_request_channel_open(Group *group, GDBusMethodInvocation *invocation,
+ gchar *uuid, gchar *channel_id, gpointer user_data)
+{
+ int ret = MDGD_ERROR_NONE;
+ const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
+
+ LOG_BEGIN();
+
+ ret = mdgd_group_request(MDGD_REQ_CHANNEL_OPEN, (char *)sender, uuid,
+ channel_id, NULL, NULL, NULL);
+
+ group_complete_request_channel_open(group, invocation, ret);
+
+ LOG_END();
+
+ return TRUE;
+}
+
gboolean group_set_preconfigured_pin(Group *group, GDBusMethodInvocation *invocation,
gchar *preconfigured_pin, gpointer user_data)
{
G_CALLBACK(group_send_response),
NULL);
- g_signal_connect(group_skeleton,
- "handle-send-file",
- G_CALLBACK(group_send_file),
- NULL);
-
g_signal_connect(group_skeleton,
"handle-get-local-device",
G_CALLBACK(group_get_local_device),
G_CALLBACK(group_request_channel_list),
NULL);
+ g_signal_connect(group_skeleton,
+ "handle-request-channel-open",
+ G_CALLBACK(group_request_channel_open),
+ NULL);
+
g_signal_connect(group_skeleton,
"handle-set-preconfigured-pin",
G_CALLBACK(group_set_preconfigured_pin),
int mdgd_group_delete(char *name)
{
int ret = MDGD_ERROR_NONE;
- mdgd_device_t **devices = NULL;
+ mdgd_device_t **devices;
int device_count = 0;
LOG_BEGIN();
if (mdgd_db_check_device_exist((char *)devices[i]) == false)
mdgd_iot_unpair(name, devices[i]->device_id);
- mdgd_clean_device(devices[i]);
}
/* delete group */
mdgd_db_group_delete(name);
- if (devices != NULL)
- g_free(devices);
-
LOG_END();
return ret;
else
LOG_ERR("Unknown Resource Type");
- mdgd_clean_user_data(data);
-
LOG_END();
return G_SOURCE_REMOVE;
va = mdgd_create_variant_dummy();
break;
case MDGD_EVENT_REQ_CHANNEL_LIST_FINISH:
+ case MDGD_EVENT_REQ_CHANNEL_OPEN_FINISH:
+ case MDGD_EVENT_RECEIVE_OPEN_CHANNEL:
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:
- va = mdgd_create_variant_receive_file((mdgd_receive_file_t *)user_data);
- break;
default:
LOG_ERR("Unknown event : %d", type);
break;
}
mdgd_command_t *cmd = (mdgd_command_t *)g_try_malloc0(sizeof(mdgd_command_t));
- if (cmd == NULL) {
- LOG_ERR("cmd allocated failed");
- continue;
- }
-
mdgd_device_t *device = (mdgd_device_t *)g_try_malloc0(sizeof(mdgd_device_t));
- if (device == NULL) {
- LOG_ERR("device allocated failed");
- g_free(cmd);
- continue;
- }
int port = selDev->endpoint.port;
int conn_type = selDev->connType;
g_free(addr);
g_free(host_addr);
- free(uuid_str);
}
return result;
}
mdgd_device_t *device = (mdgd_device_t *)g_try_malloc0(sizeof(mdgd_device_t));
- if (device == NULL) {
- LOG_ERR("device allocated failed");
- continue;
- }
-
char *device_name = NULL;
char *model_name = NULL;
char *platform_ver = NULL;
{
LOG_BEGIN();
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
- mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx, MDGD_ERROR_INVALID_PARAMETER);
-
- if (mdgd_ctx->device) {
- if (mdgd_ctx->device->device_id) {
- free(mdgd_ctx->device->device_id);
- mdgd_ctx->device->device_id = NULL;
- }
-
- if (mdgd_ctx->device->model_name) {
- g_free(mdgd_ctx->device->model_name);
- mdgd_ctx->device->model_name = NULL;
- }
-
- if (mdgd_ctx->device->device_name) {
- g_free(mdgd_ctx->device->device_name);
- mdgd_ctx->device->device_name = NULL;
- }
-
- if (mdgd_ctx->device->platform_ver) {
- g_free(mdgd_ctx->device->platform_ver);
- mdgd_ctx->device->platform_ver = NULL;
- }
-
- if (mdgd_ctx->device->vendor_id) {
- g_free(mdgd_ctx->device->vendor_id);
- mdgd_ctx->device->vendor_id = NULL;
- }
- }
-
+ //iot deinitiatlize
LOG_END();
using namespace OC;
using namespace std;
-#define PORT 8675
-#define MAXBUF 1024
-
-/* FILE Send in thread */
-static gpointer __file_send_thread_func(gpointer user_data)
-{
- int ret = MDGD_ERROR_NONE;
- int sock;
- struct sockaddr_in serveraddr;
- struct sockaddr_in6 serveraddr_v6;
- int retval;
- mdgd_command_t *cmd = (mdgd_command_t *)user_data;
- long num_read;
- long num_total = 0;
- int prev_percent = 0;
- int cur_percent = 0;
- FILE *fd = NULL;
- char buf[MAXBUF];
- long total_bytes;
- char tempaddr[26] = {
- 0,
- };
- char *temp_for_strtok = NULL;
- char *ret_ptr = NULL;
-
- LOG_BEGIN();
-
- if (cmd == NULL) {
- LOG_ERR("cmd is NULL");
- return NULL;
- }
-
- /* create socket */
- if (cmd->conn_type & CT_IP_USE_V6)
- sock = socket(AF_INET6, SOCK_STREAM, 0);
- else
- sock = socket(AF_INET, SOCK_STREAM, 0);
-
- if (sock < 0) {
- LOG_ERR("socket() error");
- ret = MDGD_ERROR_OPERATION_FAILED;
- goto SEND_THREAD_EXIT;
- }
-
- if (cmd->conn_type & CT_IP_USE_V6) {
- serveraddr_v6.sin6_family = AF_INET6;
- serveraddr_v6.sin6_port = htons(PORT);
- serveraddr_v6.sin6_flowinfo = 0;
- serveraddr_v6.sin6_scope_id = if_nametoindex("wlan0");
-
- sscanf(cmd->addr, "coaps://[%s", (char *)tempaddr);
- ret_ptr = strtok_r(tempaddr, "%", &temp_for_strtok);
-
- inet_pton(AF_INET6, ret_ptr, &serveraddr_v6.sin6_addr);
- retval = connect(sock, (struct sockaddr *)&serveraddr_v6, sizeof(serveraddr_v6));
- } else {
- serveraddr.sin_family = AF_INET;
- serveraddr.sin_port = htons(PORT);
-
- sscanf(cmd->addr, "coaps://%s", (char *)tempaddr);
- ret_ptr = strtok_r(tempaddr, ":", &temp_for_strtok);
-
- inet_pton(AF_INET, ret_ptr, &serveraddr.sin_addr.s_addr);
- retval = connect(sock, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
- }
-
- LOG_DEBUG("Connect to %s. Sending %s file...", ret_ptr, cmd->arg1);
-
- /* connect */
- if (retval < 0) {
- char buf[128];
- char const *str = strerror_r(errno, buf, 128);
- LOG_ERR("connect() error : %s", str);
- ret = MDGD_ERROR_OPERATION_FAILED;
- goto SEND_THREAD_EXIT;
- }
-
- fd = fopen(cmd->arg1, "rb");
- if (fd == NULL) {
- char buf[128];
- char const *str = strerror_r(errno, buf, 128);
- LOG_ERR("fopen() error : %s", str);
- ret = MDGD_ERROR_OPERATION_FAILED;
- goto SEND_THREAD_EXIT;
- }
-
- fseek(fd, 0, SEEK_END);
- total_bytes = ftell(fd);
- rewind(fd);
-
- while (1) {
- num_read = fread(buf, 1, MAXBUF, fd);
- if (num_read > 0) {
- prev_percent = cur_percent;
- retval = write(sock, buf, num_read);
- if (retval == -1) {
- char buf[128];
- char const *str = strerror_r(errno, buf, 128);
- LOG_ERR("write() error : %s", str);
-
- ret = MDGD_ERROR_OPERATION_FAILED;
- goto SEND_THREAD_EXIT;
- }
- num_total += num_read;
- cur_percent = (int)(((gdouble)num_total / (gdouble)total_bytes) * 100);
-
- if (prev_percent != cur_percent) {
- LOG_DEBUG("The file is %d percent sended", cur_percent);
-
- mdgd_gdbus_emit_event(cmd->sender, MDGD_EVENT_SEND_FILE_PROGRESS, MDGD_ERROR_NONE,
- mdgd_create_variant_progress(cmd->arg1, num_total, total_bytes, cur_percent));
- }
- } else if (num_read == 0 && num_total == total_bytes) {
- LOG_DEBUG("file trans complete : %ld bytes\n", num_total);
- break;
- } else {
- char buf[128];
- char const *str = strerror_r(errno, buf, 128);
- LOG_ERR("file I/O error : %s", str);
-
- ret = MDGD_ERROR_OPERATION_FAILED;
- goto SEND_THREAD_EXIT;
- }
- }
-
-SEND_THREAD_EXIT:
- if (fd != NULL)
- fclose(fd);
-
- if (sock > 0)
- close(sock);
-
- mdgd_gdbus_emit_event(cmd->sender, MDGD_EVENT_SEND_FILE_FINISH, ret,
- mdgd_create_variant_dummy());
-
- LOG_END();
-
- g_thread_exit(NULL);
- return NULL;
-}
-
static void __get_group_information(const HeaderOptions &headerOptions,
const OCRepresentation &rep, const int eCode, void *user_data)
{
LOG_ERR("Exception %s in on get", e.what());
}
- mdgd_clean_user_data(user_data);
-
LOG_END();
}
mdgd_context_mutex_unlock();
- mdgd_clean_user_data(user_data);
-
LOG_END();
}
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());
+ channel->remote_address = g_strdup("TEMP");
mdgd_group_notify_event(cmd->sender, MDGD_EVENT_REQ_CHANNEL_LIST_FINISH, ret, (void *)channel);
mdgd_clean_channel(channel);
}
- } 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 if (cmd->type == MDGD_REQ_CHANNEL_OPEN) {
+ mdgd_channel_t *channel = g_new0(mdgd_channel_t, 1);
+ channel->device_id = g_strdup(cmd->uuid);
+ channel->channel_id = g_strdup(cmd->arg1);
+ channel->remote_address = g_strdup(cmd->addr);
+ mdgd_group_notify_event(cmd->sender, MDGD_EVENT_REQ_CHANNEL_OPEN_FINISH, ret, (void *)channel);
+ mdgd_clean_channel(channel);
}
} else {
LOG_ERR("__get_device_description Response error %d", eCode);
LOG_ERR("Exception %s in on get", e.what());
}
- mdgd_clean_user_data(user_data);
-
LOG_END();
}
rep.setValue("GroupName", std::string(cmd->arg1));
resource->put(rep, QueryParamsMap(), std::bind(&__send_event_finish, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
-
- mdgd_clean_user_data(user_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) {
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;
break;
case MDGD_REQ_CHANNEL_LIST:
break;
+ case MDGD_REQ_CHANNEL_OPEN:
+ rep.setValue("ChannelID", std::string(cmd->arg1));
+ cmd->addr = g_strdup(resource->host().c_str());
+ break;
default:
LOG_ERR("Invalid command %d", cmd->type);
return FALSE;
auto found_cb = std::bind(&_found_resource, std::placeholders::_1, cmd);
- ret = OCPlatform::findResource("", requestURI.str(), CT_ADAPTER_IP, found_cb);
+ ret = OCPlatform::findResource("", requestURI.str(), (OCConnectivityType)(CT_ADAPTER_IP | CT_IP_USE_V4), found_cb);
} catch (OCException &e) {
LOG_ERR("Failed to find resource %s", e.what());
LOG_ERR("Exception %s in on get", e.what());
}
- mdgd_clean_user_data(user_data);
-
LOG_END();
}
using namespace OC;
using namespace std;
-#define PORT 8675
-#define MAXBUF 1024
-
typedef struct {
std::shared_ptr<OC::OCResourceResponse> pResponse;
} OCResourceResponse_t;
map<string, OCResourceHandle> addedResList;
-/* FILE Receive in thread */
-static gpointer __file_receive_thread_func(gpointer user_data)
-{
- LOG_BEGIN();
-
- int server_sockfd = 0;
- int client_sockfd = 0;
- int fd = 0;
- struct sockaddr_in serveraddr, clientaddr;
- struct sockaddr_in6 serveraddr_v6, clientaddr_v6;
- char client_ipaddr[INET_ADDRSTRLEN];
- char client_ipaddr_v6[INET6_ADDRSTRLEN];
- int file_read_len;
- socklen_t client_len;
- struct linger ling;
- mdgd_receive_file_t *receive_file = (mdgd_receive_file_t *)user_data;
- struct timeval tv_timeo = {3, 0};
-
- 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;
- }
- if (receive_file->conn_type == NULL) {
- LOG_ERR("receive_file->conn_type is NULL");
- goto RECEIVE_THREAD_EXIT;
- }
-
- 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) {
- char buf[128];
- const char *str = strerror_r(errno, buf, 128);
- LOG_ERR("file open error : %s", str);
-
- goto RECEIVE_THREAD_EXIT;
- }
-
- ling.l_onoff = 1;
- ling.l_linger = 0;
-
- if (g_strcmp0(receive_file->conn_type, "V6") == 0)
- server_sockfd = socket(AF_INET6, SOCK_STREAM, 0);
- else
- server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
-
- if (server_sockfd == -1) {
- char buf[128];
- const char *str = strerror_r(errno, buf, 128);
- LOG_ERR("socket error : %s", str);
-
- goto RECEIVE_THREAD_EXIT;
- }
-
- setsockopt(server_sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv_timeo, sizeof(tv_timeo));
- setsockopt(server_sockfd, SOL_SOCKET, SO_LINGER, &ling, sizeof(ling));
-
- if (g_strcmp0(receive_file->conn_type, "V6") == 0) {
- bzero(&serveraddr_v6, sizeof(serveraddr_v6));
- serveraddr_v6.sin6_family = AF_INET6;
- serveraddr_v6.sin6_addr = in6addr_any;
- serveraddr_v6.sin6_port = htons(PORT);
- serveraddr_v6.sin6_flowinfo = 0;
- serveraddr_v6.sin6_scope_id = if_nametoindex("wlan0");
-
- if (bind(server_sockfd, (struct sockaddr *)&serveraddr_v6, sizeof(serveraddr_v6)) < 0) {
- char buf[128];
- const char *str = strerror_r(errno, buf, 128);
- LOG_ERR("bind error : %s", str);
-
- goto RECEIVE_THREAD_EXIT;
- }
- } else {
- 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) {
- char buf[128];
- const char *str = strerror_r(errno, buf, 128);
- LOG_ERR("bind error : %s", str);
-
- goto RECEIVE_THREAD_EXIT;
- }
- }
-
- if (listen(server_sockfd, 5) != 0) {
- char buf[128];
- const char *str = strerror_r(errno, buf, 128);
- LOG_ERR("listen error : %s", str);
-
- goto RECEIVE_THREAD_EXIT;
- }
-
- if (g_strcmp0(receive_file->conn_type, "V6") == 0) {
- client_len = sizeof(clientaddr_v6);
- client_sockfd = accept(server_sockfd, (struct sockaddr *)&clientaddr_v6, &client_len);
- inet_ntop(AF_INET6, &clientaddr_v6.sin6_addr, client_ipaddr_v6, sizeof(client_ipaddr_v6));
- LOG_DEBUG("Accepted IP : %s, client socket : %d", client_ipaddr_v6, client_sockfd);
- } else {
- client_len = sizeof(clientaddr);
- client_sockfd = accept(server_sockfd, (struct sockaddr *)&clientaddr, &client_len);
- inet_ntop(AF_INET, &clientaddr.sin_addr.s_addr, client_ipaddr, sizeof(client_ipaddr));
- LOG_DEBUG("Accepted IP : %s, client socket : %d", client_ipaddr, client_sockfd);
- }
-
- if (client_sockfd == -1) {
- char buf[128];
- const char *str = strerror_r(errno, buf, 128);
- LOG_ERR("socket error : %s", str);
-
- goto RECEIVE_THREAD_EXIT;
- }
-
- while (1) {
- ssize_t len = 0;
- char buf[MAXBUF] = {
- 0,
- };
- file_read_len = read(client_sockfd, buf, MAXBUF);
- if (file_read_len > 0)
- len = write(fd, buf, file_read_len);
-
- if (0 < len) {
- LOG_ERR("write error");
- }
-
- 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);
-
- break;
- }
- }
-
-RECEIVE_THREAD_EXIT:
- if (fd > 0)
- close(fd);
-
- if (client_sockfd > 0)
- close(client_sockfd);
-
- if (server_sockfd > 0)
- close(server_sockfd);
-
- if (receive_file != NULL) {
- if (receive_file->file_path != NULL)
- g_free(receive_file->file_path);
-
- if (receive_file->device_id != NULL)
- g_free(receive_file->device_id);
-
- if (receive_file->conn_type != NULL)
- g_free(receive_file->conn_type);
-
- g_free(receive_file);
- }
-
- LOG_END();
-
- g_thread_exit(NULL);
- 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)
mdgd_group_notify_event(sender, MDGD_EVENT_RECEIVE_DATA, result, receive_data);
} else {
- std::string group_name, uuid;
+ std::string group_name, uuid, channel_id;
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");
free(group_name_str);
free(uuid_str);
} break;
- case MDGD_REQ_CHANNEL_LIST:
+ case MDGD_REQ_CHANNEL_LIST: {
LOG_DEBUG("Request channel list");
GHashTableIter iter;
char *key;
responseRep.setValue(std::string(channel_id), "NONE");
g_free(channel_id);
}
+ break;
+ }
+ case MDGD_REQ_CHANNEL_OPEN: {
+ LOG_DEBUG("Request channel open");
+ GHashTableIter iter;
+
+ if (!requestRep.getValue("ChannelID", channel_id))
+ LOG_ERR("ChannelID not found");
+
+ LOG_DEBUG("channel id : %s", channel_id.c_str());
+
+ g_hash_table_iter_init(&iter, mdgd_ctx->channel);
+
+ char *sender = (char *)g_hash_table_lookup(mdgd_ctx->channel, channel_id.c_str());
+
+ if (sender != NULL) {
+ mdgd_channel_t *channel = (mdgd_channel_t *)g_try_malloc0(sizeof(mdgd_channel_t));
+ channel->device_id = g_strdup(requester_id.c_str());
+ channel->channel_id = g_strdup(channel_id.c_str());
+ channel->remote_address = g_strdup("TEMP");
+
+ LOG_DEBUG("sender is %s", sender);
+ mdgd_group_notify_event(sender, MDGD_EVENT_RECEIVE_OPEN_CHANNEL, result, channel);
+ }
break;
+ }
default:
LOG_ERR("Unknown request command %d", cmd);
break;
#include <mdgd_gdbus.h>
#include <mdgd_group.h>
#include <mdgd_resource.h>
+#include <storage-internal.h>
+#include <wifi-manager.h>
int main(int argc, char *argv[])
{
int ret;
- LOG_DEBUG("COMP Manager start");
+ LOG_DEBUG("COMP Manager start - Wait preconditions");
+
+ for (int i = 0; i < 10; i++) {
+ storage_part_mount_e mounted;
+ ret = storage_is_mounted_opt_usr(&mounted);
+ if (ret == STORAGE_ERROR_NONE
+ && mounted == STORAGE_PART_MOUNTED) {
+ break;
+ }
+ LOG_ERR("wait a mount /opt/usr path");
+ usleep(200000);
+ }
+
+ for (int i = 0; i < 10; i++) {
+ wifi_manager_h wifi_handle = NULL;
+ wifi_manager_ap_h ap = NULL;
+
+ ret = wifi_manager_initialize(&wifi_handle);
+ if (ret != WIFI_MANAGER_ERROR_NONE || wifi_handle == NULL) {
+ LOG_DEBUG("wifi init failed %d", ret);
+ usleep(1000000);
+ continue;
+ }
+
+ ret = wifi_manager_get_connected_ap(wifi_handle, &ap);
+ if (ret == WIFI_MANAGER_ERROR_NONE && ap != NULL) {
+ LOG_DEBUG("wifi is connected ");
+ break;
+ }
+ LOG_ERR("wait a ap connect");
+ usleep(1000000);
+ }
+
+ LOG_DEBUG("Wait preconditions end");
//1. create & get context
ret = mdgd_context_create();
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_new_string(channel->device_id));
g_variant_builder_add(builder, "{sv}", "ChannelID",
g_variant_new_string(channel->channel_id));
+ g_variant_builder_add(builder, "{sv}", "RemoteAddress",
+ g_variant_new_string(channel->remote_address));
va = g_variant_builder_end(builder);
return va;
}
-GVariant *mdgd_create_variant_progress(char *file_path,
- long send_size, long total_size, int percent)
-{
- GVariant *va;
-
- GVariantBuilder *builder;
-
- builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
-
- g_variant_builder_add(builder, "{sv}", "FilePath",
- g_variant_new_string(file_path));
-
- g_variant_builder_add(builder, "{sv}", "SendSize",
- g_variant_new_int64(send_size));
-
- g_variant_builder_add(builder, "{sv}", "TotalSize",
- g_variant_new_int64(total_size));
-
- g_variant_builder_add(builder, "{sv}", "Percent",
- g_variant_new_int32(percent));
-
- va = g_variant_builder_end(builder);
-
- g_variant_builder_unref(builder);
-
- return va;
-}
-
GVariant *mdgd_create_variant_device_list(char *group_name)
{
GVariant *va;
projects / platform / core / connectivity / mdg-manager.git / commitdiff