#ifndef __MDGD_CONTEXT_H__
#define __MDGD_CONTEXT_H__
-#include <glib.h>
-#include <mdgd_log.h>
-#include <unistd.h>
-#include <gio/gio.h>
-#include <mdg_gdbus.h>
-#include <sys/types.h>
-#include <sqlite3.h>
+#include <mdgd_util.h>
#ifdef __cplusplus
extern "C"
{
#endif
-typedef struct {
- GMainLoop *main_loop;
- //GDBusConnection *connection;
- int ref_count;
-
- // resource list
- GList *resource_list[MDGD_RESOURCE_TYPE_MAX];
-
- char *device_uuid;
- bool mot_me; /**< Indicator whether mot local comp-manager */
- GList *grp_list;
- GList *pairwise_list;
-
- bool monitor_started;
- bool first_search;
-
- //sqlite3 db
- sqlite3 *db;
-} mdgd_context_t;
-
-typedef struct {
- char *conn_name;
- int conn_id;
- GDBusConnection *connection;
-} mdgd_conn_destroy_data;
-
int mdgd_context_create();
int mdgd_context_destroy();
void mdgd_context_mutex_lock();
int mdgd_db_init();
int mdgd_db_deinit();
int mdgd_db_group_insert(const char *group_name);
-int mdgd_db_device_insert(const char *device_id, const char *group_name);
+int mdgd_db_device_insert(const char *group_name, const char *device_id);
int mdgd_db_group_delete(char *group_name);
-int mdgd_db_device_delete(char *device_id, char *group_name);
-bool mdgd_check_device_exist(char *device_id);
-bool mdgd_check_group_exist(const char *group_name);
+int mdgd_db_device_delete(char *group_name, char *device_id);
+bool mdgd_db_check_device_exist(char *device_id);
+bool mdgd_db_check_device_exist_in_group(char *group_name, char *device_id);
+bool mdgd_db_check_group_exist(const char *group_name);
+void mdgd_db_get_groups(char **groups, int *group_count);
+void mdgd_db_get_devices_in_group(char *group_name, char **devices, int *device_count);
+int mdgd_db_group_print();
+int mdgd_db_device_print();
#ifdef __cplusplus
}
#ifndef __MDGD_GDBUS_H__
#define __MDGD_GDBUS_H__
-#include <mdgd_gdbus_group.h>
+#include <mdgd_context.h>
#ifdef __cplusplus
extern "C"
#define MDGD_DBUS_SERVICE "org.tizen.mdg" /**< For mdg dbus */
#define MDGD_DBUS_GROUP_PATH "/org/tizen/mdg/group" /**< For group commands */
#define MDGD_DBUS_ENABLER_PATH "/org/tizen/mdg/enabler" /**< For d-bus activation */
+#define DBUS_SERVICE_DBUS "org.freedesktop.DBus"
+#define DBUS_INTERFACE_DBUS "org.freedesktop.DBus"
+void mdgd_gdbus_emit_event(mdgd_event_type_e type, int ret, GVariant *data);
int mdgd_gdbus_init();
#ifdef __cplusplus
+++ /dev/null
-/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef __MDGD_GDBUS_GROUP_H__
-#define __MDGD_GDBUS_GROUP_H__
-
-#include <mdgd_group.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-Group *group_dbus_get_object();
-
-gboolean group_create(Group *group, GDBusMethodInvocation *invocation, gchar *group_name,
- gpointer user_data);
-
-gboolean group_find(Group *group, GDBusMethodInvocation *invocation, gint timeout,
- gpointer user_data);
-
-gboolean group_get_found_groups(Group *group, GDBusMethodInvocation *invocation,
- gpointer user_data);
-
-gboolean group_join(Group *group, GDBusMethodInvocation *invocation,
- gpointer user_data);
-
-gboolean group_leave(Group *group, GDBusMethodInvocation *invocation,
- gpointer user_data);
-
-gboolean group_delete(Group *group, GDBusMethodInvocation *invocation,
- gchar *group_name, gpointer user_data);
-
-gboolean group_device_find(Group *group, GDBusMethodInvocation *invocation,
- gint timeout, gpointer user_data);
-
-gboolean group_device_invite(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid_dev1, gchar *uuid_dev2, gchar *pin, gchar *uri_1, gchar *rt_1,
- gchar *interface_1, int permission_1, gchar *uri_2, gchar *rt_2,
- gchar *interface_2, int permission_2, gpointer user_data);
-
-gboolean group_device_eject(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid_dev1, gchar *uuid_dev2, gpointer user_data);
-
-gboolean group_invite(Group *group, GDBusMethodInvocation *invocation, gchar *group_name,
- gchar *uuid, gchar *pin, gpointer user_data);
-
-gboolean group_eject(Group *group, GDBusMethodInvocation *invocation, gchar *group_name,
- gchar *uuid, gpointer user_data);
-
-gboolean group_get_remote_device(Group *group, GDBusMethodInvocation *invocation,
- gpointer user_data);
-
-gboolean group_pair_resource(Group *group, GDBusMethodInvocation *invocation,
- gchar *target_1, gchar *subject_1, gchar *uri_1, gchar *rt_1,
- gchar *interface_1, int permission_1, gchar *target_2, gchar *subject_2,
- gchar *uri_2, gchar *rt_2, gchar *interface_2, int permission_2,
- gpointer user_data);
-
-gboolean group_unpair_resource(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid_dev1, gchar *uuid_dev2, gpointer user_data);
-
-gboolean group_send_data(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid_dev, gchar *addr, int port, GVariant *params,
- gpointer user_data);
-
-gboolean group_find_mowned_devices(Group *group,
- GDBusMethodInvocation *invocation, int timeout, gpointer user_data);
-
-gboolean group_get_mowned_device(Group *group,
- GDBusMethodInvocation *invocation, gpointer user_data);
-
-gboolean group_get_my_mowned_device(Group *group,
- GDBusMethodInvocation *invocation, gpointer user_data);
-
-gboolean group_get_my_uuid(Group *group,
- GDBusMethodInvocation *invocation, gpointer user_data);
-
-gboolean group_request_create_group(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gchar *group_name, gpointer user_data);
-
-gboolean group_request_invite(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gchar *group_name, gchar *target_uuid, gchar *PIN, gpointer user_data);
-
-gboolean group_request_eject(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gchar *group_name, gchar *target_uuid, gpointer user_data);
-
-gboolean group_request_delete_group(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gchar *group_name, gpointer user_data);
-
-gboolean group_start_invited_device_monitor(Group *group,
- GDBusMethodInvocation *invocation, int start,
- gpointer user_data);
-
-void notify_group_found(GVariant *group_data);
-void notify_group_find_finish(int ret);
-void notify_device_found(int device_count, GVariant *device_data);
-void notify_device_find_finish(int ret);
-void notify_group_device_invite_result(int ret);
-void notify_group_device_eject_result(int ret);
-void notify_mowned_device_found(int device_count, GVariant *device_data);
-void notify_mowned_device_find_finish(int ret);
-void notify_group_join(int result);
-void notify_send_data_finish(const char *resp_data, int ret);
-void notify_request_result(const char *cmd, const char *requester_id,
- unsigned char *arg, int len, int ret);
-void notify_device_monitor_result(const char *uuid, const char *group_name,
- const char *status);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* __MDGD_GDBUS_GROUP_H__ */
{
#endif
-typedef struct {
- char *uri_path; /**< URI path */
- char *device_id; /**< Device ID */
- char *host_addr; /**< Host address */
- char *group_name; /**< Group name */
- char *resource_type; /**< Resource type */
- mdgd_group_type_e type; /**< Group yype */
-} mdgd_group_t;
-
-typedef struct {
- char *device_id; /**< Device Id */
- int adapter; /**< Adapter type */
- int flags; /**< Flags */
- int port; /**< Remtoe device is listening this port */
- char *addr; /**< IP Address of remote device */
- int ifindex; /**< Network interfce index of Remote device */
- char *route_data; /**< Route data */
- char *remote_id; /**< Remote Id */
- int conn_type; /**< Connection type */
- int secure_port; /**< Secured port once TLS handhaking complete */
- int tcp_port; /**< TCP port when using CoAP over TCP */
- char *sec_ver; /**< OCF Security specification version */
- int dev_status; /**< Device status */
- char *model_name; /**< Device ID */
- char *device_name; /**< Host address */
- char *platform_ver; /**< Group name */
- char *vendor_id; /**< Resource type */
- char *profile; /**< Group yype */
- bool mowned;
- mdgd_device_type_e type;
-} mdgd_mot_device_t;
-
-typedef struct {
- char *group_name;
- char *uuid_dev1; /**< Source device Id */
- char *uuid_dev2; /**< Target device Id */
- char *pin; /**< Random or pre-configured PIN */
- char *uri_1; /**< URI at source resource */
- char *rt_1; /**< Resource type at source resource */
- char *interface_1; /**< Interface at source resource */
- int permission_1; /**< CRUDN for target device */
- char *uri_2; /**< URI at target resource */
- char *rt_2; /**< Resource type at target resource */
- char *interface_2; /**< Interface at target resource */
- int permission_2; /**< CRUDN for source device */
-} mdgd_group_invite_info_t;
-
-typedef struct {
- char *group_name; /**< Group Name */
- char *uuid; /**< Device ID */
- char *host; /**< Device Host Address */
- int count; /**< Count of successful post method */
-} mdgd_invited_device_t;
-
-typedef struct {
- char *name; /**< Group name */
- GList *device_list; /**< Remote device UUIDs. (char* type) */
-} mdgd_grp_t;
-
-/* Called when daemon is start. */
-int mdgd_group_initialize();
-
-/* create group and destroy */
+/* Group Manangement */
int mdgd_group_create(const char* name);
-int mdgd_group_destroy(const char* name);
+int mdgd_group_delete(const char* name);
-/* Find Remote groups */
int mdgd_group_find(int timeout);
-GVariant *mdgd_group_get_found_groups();
-int mdgd_group_add_new(char *uri_path, char *device_id, char *device_name,
- char *host_addr, char *resource_type, mdgd_group_type_e type);
-
-/* Join the remote devices in my daemon */
-int mdgd_group_get_groups(mdgd_group_t ***handles, int *count); //Get all of group in my daemon
-int mdgd_group_get_remote_devices(/* callback */); //Get all of device in network (Async)
-
-int mdgd_group_add_new_mot_device(mdgd_mot_device_t *device);
-void mdgd_group_notify_mot_enable_device_done();
-int mdgd_group_find_mot_enabled_devices(int timeout);
+int mdgd_group_found(mdgd_group_t *group);
+int mdgd_group_find_result(int timeout);
-char *mdgd_group_invite_get_uuid();
-char *mdgd_group_invite_get_pin();
+int mdgd_group_find_device(int timeout, bool is_invited);
+int mdgd_group_found_device(mdgd_device_t *device);
+int mdgd_group_find_device_result(int timeout);
-/* Join to device in group (async) */
-int mdgd_group_invite(const char *group_name, const char *uuid,
- const char *pin);
-mdgd_group_invite_info_t *mdgd_group_get_invite_info();
-void mdgd_group_free_invite_info();
-void mdgd_group_notify_group_invite(int result);
+int mdgd_group_invite_device(const char *group_name, const char *uuid, const char *pin);
+void mdgd_group_notify_invite_device(int result);
-/* eject from group (async) */
-int mdgd_group_eject(const gchar *group_name, gchar *uuid_dev1, const char *uuid_dev2);
-void mdgd_group_notify_group_dismiss(int result);
+int mdgd_group_eject_device(const char *group_name, const char *uuid);
+void mdgd_group_notify_eject_device(int result);
-int mdgd_group_pair_resource(char* target1, char *subject1, char *uri1,
- char *rt1, char *interface1, int permission1, char* target2, char *subject2,
- char *uri2, char *rt2, char *interface2, int permission2);
+int mdgd_group_regist_channel(char *channel_id, char *sender);
+int mdgd_group_unregist_channel(char *channel_id, char *sender);
-int mdgd_group_unpair_resource(gchar *uuid_dev1, gchar *uuid_dev2);
int mdgd_group_send_data(gchar *uuid_dev, gchar *addr, int port,
unsigned char *data, int len);
-void mdgd_group_notify_keepalive_response(mdgd_command_t *cmd);
+void mdgd_group_notify_send_data(int result);
-GVariant *mdgd_group_get_remote_mot_enabled_devices();
-int mdgd_group_get_mot_device_count();
-
-int mdgd_group_add_new_mowned_device(mdgd_mot_device_t *device);
-void mdgd_group_notify_mowned_device_find_done();
-int mdgd_group_find_mowned_devices();
-GVariant *mdgd_group_get_mowned_devices();
-int mdgd_group_get_mowned_device_count();
-GVariant *mdgd_group_get_my_mowned_devices();
-void mdgd_group_change_mowned_device(mdgd_mot_device_t *device);
-
-/* Join to remote device group */
-int mdgd_group_join();
-int mdgd_group_leave_from(/* callback */); //leave from certain remote group (Async)
-
-/* Called when daemon is end. */
-int mdgd_group_deinitialize();
-
-/* Getter for a group */
-int mdgd_group_get_group_name(mdgd_group_t *handle, char **name);
-int mdgd_group_get_group_type(mdgd_group_t *handle, int *type);
-int mdgd_group_get_group_device_type(mdgd_group_t *handle);
-int mdgd_group_get_group_device_id(mdgd_group_t *handle);
-
-/* notify */
-int mdgd_group_event_handler(/*callback*/); // event hadnler
-int mdgd_group_add_device_in_group(const char *group_name, const char *uuid);
-int mdgd_group_remove_device_in_group(char *group_name, char *uuid);
-
-/* Group management */
+/* Group Request */
int mdgd_group_request_create_group(char *uuid, char *group_name);
int mdgd_group_request_invite(char *uuid, char *group_name, char *target_uuid, char *PIN);
int mdgd_group_request_eject(char *uuid, char *group_name, char *target_uuid);
int mdgd_group_request_delete_group(char *uuid, char *group_name);
-int mdgd_group_start_invited_device_monitor(int start);
-mdgd_mot_device_t *mdgd_group_check_device_in_mot_enb_dev_list(char *uuid);
-
#ifdef __cplusplus
}
#endif
#define __MDGD_IOT_H__
#include <mdgd_resource.h>
+#include <mdgd_group.h>
#ifdef __cplusplus
extern "C"
{
#endif
-#define SVR_PATH "/tmp/.svr.dat" /**< For Temp */
-
-typedef struct _iot_discovery_t {
- gchar *uuid; /**< Device Id */
- gchar *data; /**< Data to send */
- gchar *host; /**< Target host IP address + Port */
-} iot_discovery_t;
-
-typedef struct _mdgd_command_t {
- int tid; /**< Timer ID */
- int resource_type; /**< OCF resource type */
- mdgd_request_type_e command; /**< Comments set for group management */
- gchar *uuid; /**< Device UUID */
- gchar *host; /**< Host address + Port */
- 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;
-#endif
- void *user_data;
-} mdgd_command_t;
+#define MAX_FILE_PATH_LEN 1024
+#define SVR_DB_FILE_NAME "oic_svr_db_mdgd_manager.dat"
+#define SYSTEM_INFO_PLATFORM_VERSION "http://tizen.org/feature/platform.version"
+#define SYSTEM_INFO_MANUF_NAME "http://tizen.org/system/manufacturer"
+#define SYSTEM_INFO_MODEL_NAME "http://tizen.org/system/model_name"
+#define SYSTEM_INFO_BUILD_STRING "http://tizen.org/system/build.string"
+#define SYSTEM_INFO_TIZEN_ID "http://tizen.org/system/tizenid"
+#define SYSTEM_INFO_PROFILE "http://tizen.org/feature/profile"
int mdgd_iot_initialize();
int mdgd_iot_add_resource(mdgd_resource_type_e resource_type, const char *uri);
-int mdgd_iot_delete_resource(mdgd_resource_type_e resource_type,
- const char *uri);
int mdgd_iot_discovery_resource(mdgd_resource_type_e resource_type, int timeout, void *user_data);
int mdgd_iot_send_data(mdgd_resource_type_e resource_type, int timeout,
mdgd_command_t *cmd);
+int mdgd_iot_get_device_description(mdgd_device_t *device);
int mdgd_iot_deinitialize();
#ifdef __cplusplus
#ifndef __MDGD_LOG_H__
#define __MDGD_LOG_H__
-#include <dlog.h>
-#include <mdgd_enum.h>
+#include <mdgd_typedef.h>
#ifdef __cplusplus
extern "C"
#define NOTUSED(var) (var = var)
-#define mdgd_check_null_print_error(value, error) do { \
- /* LCOV_EXCL_START */ \
- if (G_UNLIKELY(NULL == (value))) { \
- LOGE("%s", error); \
- } \
- /* LCOV_EXCL_STOP */ \
-} while (FALSE)
-
-
#define mdgd_check_null_ret_error(name, value, error) do { \
/* LCOV_EXCL_START */ \
if (G_UNLIKELY(NULL == (value))) { \
- LOGE("%s is NULL", name); \
- return error; \
- } \
+ LOGE("%s is NULL", name); \
+ return error; \
+ } \
/* LCOV_EXCL_STOP */ \
} while (FALSE)
#define mdgd_check_null_ret(name, value) do { \
/* LCOV_EXCL_START */ \
if (G_UNLIKELY(NULL == (value))) { \
- LOGE("%s is NULL", name); \
- return; \
- } \
+ LOGE("%s is NULL", name); \
+ return; \
+ } \
/* LCOV_EXCL_STOP */ \
} while (FALSE)
+++ /dev/null
-/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef __MDGD_MANAGER_H__
-#define __MDGD_MANAGER_H__
-
-#include <mdgd_log.h>
-#include <mdgd_group.h>
-#include <mdgd_resource.h>
-#include <mdgd_gdbus.h>
-#include <mdgd_db.h>
-
-#endif /* __MDGD_MANAGER_H__ */
int agent_enable();
int agent_disable();
-int agent_get_ownerid(char* deviceid);
int agent_find_mot_enable_devices(int timeout);
int agent_find_mowned_devices();
int agent_mot(char* uuid_str, char *pin);
-int agent_resources_pairwise(char* target1, char *subject1, char *uri1,
- char *rt1, char *interface1, int permission1, char* target2, char *subject2,
- char *uri2, char *rt2, char *interface2, int permission2);
-int agent_unlink_resources(char* uuid_str1, char *uuid_str2);
-int agent_remove_subowner(char* uuid_str);
-int agent_remove_subowned(char* uuid_str);
int agent_pair(const char *pin, char* target1, const char *subject1, char *uri1,
char *rt1, char *interface1, int permission1, const char* target2,
char *subject2, char *uri2, char *rt2, char *interface2, int permission2);
{
#endif
-typedef struct {
- mdgd_resource_type_e resource_type;
- char *type;
- char *uri_prefix;
- unsigned char policies;
-} mdgd_rd_t;
-
-typedef struct {
- OCResourceHandle resource;
- char *uri;
-} mdgd_re_t;
-
-int mdgd_resource_append(mdgd_resource_type_e resource_type, const char *uri,
- OCResourceHandle resource);
char *mdgd_resource_get_type(mdgd_resource_type_e resource_type);
char *mdgd_resource_get_uri_prefix(mdgd_resource_type_e resource_type);
unsigned char mdgd_resource_get_policies(mdgd_resource_type_e resource_type);
-void mdgd_resource_print_list();
-OCResourceHandle mdgd_resource_get_handle(mdgd_resource_type_e resource_type,
- const char *uri);
#ifdef __cplusplus
}
*
*/
-#ifndef __MDGD_ENUM_H__
-#define __MDGD_ENUM_H__
+#ifndef __MDGD_TYPEDEF_H__
+#define __MDGD_TYPEDEF_H__
#include <tizen.h>
+#include <glib.h>
+#include <unistd.h>
+#include <gio/gio.h>
+#include <mdg_gdbus.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sqlite3.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <net/if.h>
+#include <arpa/inet.h>
+#include <dirent.h>
+#include <dlog.h>
+#include <error.h>
#define NOTUSED(var) (var = var) /**< It is used to avoid generating build warning */
MDGD_ERROR_ALREADY_REGISTERED = TIZEN_ERROR_MDG | 0x03, /**< Request already registered */
MDGD_ERROR_IN_PROGRESS = TIZEN_ERROR_MDG | 0x04,/**< operation is in progress */
MDGD_ERROR_COMM_ERROR = TIZEN_ERROR_MDG | 0x05, /**< communication error */
- MDGD_ERROR_RX = TIZEN_ERROR_MDG | 0x06, /**< RX error */
- MDGD_ERROR_TX = TIZEN_ERROR_MDG | 0x07, /**< TX error */
MDGD_ERROR_PLUGIN_FAIL = TIZEN_ERROR_MDG | 0x08, /**< Plugin failed */
MDGD_ERROR_ALREADY_IN_PROGRESS = TIZEN_ERROR_MDG | 0x09, /**< Already in progress */
- MDGD_ERROR_NOT_STARTED = TIZEN_ERROR_MDG | 0x0A, /**< Not Started */
- MDGD_ERROR_ALREADY_INITIALIZED = TIZEN_ERROR_MDG | 0x0B, /**< Already initilized */
+ MDGD_ERROR_DB = TIZEN_ERROR_MDG | 0x0A, /**< DB Error */
+ MDGD_ERROR_IOTIVITY = TIZEN_ERROR_MDG | 0x0B, /**< Iotivity Error */
MDGD_ERROR_UNKNOWN = -999
} mdgd_error_e;
typedef enum {
MDGD_RESOURCE_TYPE_GROUP = 0, /**< Group resource type */
MDGD_RESOURCE_TYPE_DEVICE, /**< Device resource type */
- MDGD_RESOURCE_TYPE_OPERATION, /**< Operation resource type */
MDGD_RESOURCE_TYPE_DATA, /**< Data resource type */
MDGD_RESOURCE_TYPE_MAX
} mdgd_resource_type_e;
* @since_tizen 5.0
*/
typedef enum {
- MDGD_GROUP_GROUP_ERROR = 0, /**< Group type error */
- MDGD_GROUP_GROUP_LOCAL = 1, /**< Local group type */
- MDGD_GROUP_GROUP_REMOTE = 2, /**< Remote group type */
+ MDGD_GROUP_TYPE_LOCAL = 1, /**< Local group type */
+ MDGD_GROUP_TYPE_REMOTE = 2, /**< Remote group type */
} mdgd_group_type_e;
typedef enum {
- MDGD_GROUP_DEVICE_ERROR = 0, /**< Group type error */
- MDGD_GROUP_DEVICE_LOCAL = 1, /**< Local group type */
- MDGD_GROUP_DEVICE_REMOTE = 2, /**< Remote group type */
+ MDGD_DEVICE_TYPE_LOCAL = 1, /**< Local group type */
+ MDGD_DEVICE_TYPE_REMOTE = 2, /**< Remote group type */
} mdgd_device_type_e;
/**
MDGD_REQ_SEND_DATA = 0, /**< Send data */
MDGD_REQ_CREATE_GROUP, /**< Create Group */
MDGD_REQ_INVITE_DEVICE, /**< Invite Device */
- MDGD_REQ_EJECT_DEVICE, /**< Exile Device */
+ MDGD_REQ_EJECT_DEVICE, /**< Eject Device */
MDGD_REQ_DELETE_GROUP, /**< Delete Group */
- MDGD_REQ_KEEP_ALIVE, /**< Keep Alive Message */
- MDGD_REQ_SEND_DATA_ALL, /**< Send data in subnet */
} mdgd_request_type_e;
-#endif /* __MDGD_ENUM_H__ */
+typedef enum {
+ MDGD_EVENT_GROUP_FOUND = 0,
+ MDGD_EVENT_GROUP_FIND_FINISH,
+ MDGD_EVENT_DEVICE_FOUND,
+ MDGD_EVENT_DEVICE_FIND_FINISH,
+ MDGD_EVENT_INVITE_DEVICE_FINISH,
+ MDGD_EVENT_EJECT_DEVICE_FINISH,
+ MDGD_EVENT_REQUEST_FINISH,
+ MDGD_EVENT_SEND_DATA_FINISH,
+} mdgd_event_type_e;
+
+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 */
+} mdgd_group_t;
+
+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 */
+ char *vendor_id; /**< Resource type */
+ char *profile; /**< Group yype */
+ bool is_invited;
+ mdgd_device_type_e type; /**< Group type */
+} mdgd_device_t;
+
+typedef struct {
+ GMainLoop *main_loop;
+ GHashTable *channel;
+ int ref_count;
+ char *device_uuid;
+ mdgd_device_t *device;
+ sqlite3 *db;
+ bool mot_me;
+} mdgd_context_t;
+
+typedef struct {
+ char *conn_name;
+ int conn_id;
+ GDBusConnection *connection;
+} mdgd_conn_destroy_data;
+
+typedef struct _mdgd_command_t {
+ int tid; /**< Timer ID */
+ int resource_type; /**< OCF resource type */
+ mdgd_request_type_e command; /**< Comments set for group management */
+ gchar *uuid; /**< Device UUID */
+ gchar *host; /**< Host address + Port */
+ 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;
+#endif
+ void *user_data;
+} mdgd_command_t;
+
+typedef struct _mdgd_rd_t {
+ mdgd_resource_type_e resource_type;
+ char *type;
+ char *uri_prefix;
+ char *policies;
+} mdgd_rd_t;
+
+#endif /* __MDGD_TYPEDEF_H__ */
{
#endif
+#include <octypes.h>
+#include <pmtypes.h>
+#include <mdgd_log.h>
+
#define LOCAL_IP 1 /**< Local IP */
#define REMOTE_IP 2 /**< Remote IP */
void mdgd_remove_ip_info(void);
int mdgd_make_ip_info(void);
int mdgd_is_local_ip(char *ipdata);
+char *mdgd_addr2host(char *addr, int port, bool is_secure);
+int mdgd_uuid_to_str(const OicUuid_t* uuid, char** strUuid);
+void mdgd_clean_user_data(void *user_data);
+GVariant *mdgd_create_variant_group(mdgd_group_t *group);
+GVariant *mdgd_create_variant_device(mdgd_device_t *device);
+GVariant *mdgd_create_variant_dummy();
+
#ifdef __cplusplus
}
<arg type="i" name="timeout" direction="in" />
<arg type="i" name="result" direction="out" />
</method>
- <method name="GetFoundGroups">
- <arg type="i" name="result" direction="out" />
- <arg type="aa{sv}" name="groups" direction="out" />
- </method>
- <method name="Join">
- <arg type="i" name="result" direction="out" />
- </method>
- <method name="Leave">
- <arg type="i" name="result" direction="out" />
- </method>
<method name="Delete">
- <arg type="s" name="group_name" direction="in"/>
- <arg type="i" name="result" direction="out"/>
+ <arg type="s" name="group_name" direction="in" />
+ <arg type="i" name="result" direction="out" />
</method>
- <method name="DeviceFind">
+ <method name="FindDevice">
<arg type="i" name="timeout" direction="in" />
+ <arg type="i" name="is_invited" direction="in" />
<arg type="i" name="result" direction="out" />
</method>
- <method name="Invite">
+ <method name="InviteDevice">
<arg type="s" name="group_name" direction="in"/>
<arg type="s" name="uuid" direction="in"/>
<arg type="s" name="pin" direction="in" />
<arg type="i" name="result" direction="out"/>
</method>
- <method name="Eject">
+ <method name="EjectDevice">
<arg type="s" name="group_name" direction="in"/>
<arg type="s" name="uuid" direction="in"/>
<arg type="i" name="result" direction="out" />
</method>
- <method name="DeviceInvite">
- <arg type="s" name="uuid_dev1" direction="in"/>
- <arg type="s" name="uuid_dev2" direction="in"/>
- <arg type="s" name="pin" direction="in" />
- <arg type="s" name="uri_1" direction="in"/>
- <arg type="s" name="rt_1" direction="in"/>
- <arg type="s" name="interface_1" direction="in"/>
- <arg type="i" name="permission_1" direction="in"/>
- <arg type="s" name="uri_2" direction="in"/>
- <arg type="s" name="rt_2" direction="in"/>
- <arg type="s" name="interface_2" direction="in"/>
- <arg type="i" name="permission_2" direction="in"/>
- <arg type="i" name="result" direction="out"/>
+ <method name="GetLocalDevice">
+ <arg type="a{sv}" name="device_info" direction="out" />
</method>
- <method name="DeviceEject">
- <arg type="s" name="uuid_dev1" direction="in"/>
- <arg type="s" name="uuid_dev2" direction="in"/>
- <arg type="i" name="result" direction="out" />
+ <method name="GetMemberDevices">
+ <arg type="s" name="group_name" direction="in"/>
+ <arg type="aa{sv}" name="devices" direction="out" />
</method>
- <method name="GetRemoteDevice">
- <arg type="i" name="device_count" direction="out" />
- <arg type="aa{sv}" name="device_info" direction="out" />
- </method>
- <method name="PairResource">
- <arg type="s" name="target_1" direction="in"/>
- <arg type="s" name="subject_1" direction="in"/>
- <arg type="s" name="uri_1" direction="in"/>
- <arg type="s" name="rt_1" direction="in"/>
- <arg type="s" name="interface_1" direction="in"/>
- <arg type="i" name="permission_1" direction="in"/>
- <arg type="s" name="target_2" direction="in"/>
- <arg type="s" name="subject_2" direction="in"/>
- <arg type="s" name="uri_2" direction="in"/>
- <arg type="s" name="rt_2" direction="in"/>
- <arg type="s" name="interface_2" direction="in"/>
- <arg type="i" name="permission_2" direction="in"/>
- <arg type="i" name="result" direction="out"/>
+ <method name="RegistChannel">
+ <arg type="s" name="channel_id" direction="in"/>
+ <arg type="i" name="result" direction="out" />
</method>
- <method name="UnpairResource">
- <arg type="s" name="uuid_dev1" direction="in"/>
- <arg type="s" name="uuid_dev2" direction="in"/>
- <arg type="i" name="result" direction="out"/>
+ <method name="UnregistChannel">
+ <arg type="s" name="channel_id" direction="in"/>
+ <arg type="i" name="result" direction="out" />
</method>
<method name="SendData">
<arg type="s" name="uuid" direction="in" />
<arg type="(iay)" name="data" direction="in"/>
<arg type="i" name="result" direction="out" />
</method>
- <method name="FindMownedDevices">
- <arg type="i" name="timeout" direction="in" />
- <arg type="i" name="result" direction="out" />
- </method>
- <method name="GetMownedDevice">
- <arg type="i" name="device_count" direction="out" />
- <arg type="aa{sv}" name="device_info" direction="out" />
- </method>
- <method name="GetMyMownedDevice">
- <arg type="a{sv}" name="device_info" direction="out" />
- </method>
- <method name="GetMyUuid">
- <arg type="s" name="uuid" direction="out" />
- </method>
<method name="RequestCreateGroup">
<arg type="s" name="uuid" direction="in" />
<arg type="s" name="group_name" direction="in" />
<arg type="s" name="group_name" direction="in" />
<arg type="i" name="result" direction="out" />
</method>
- <method name="StartInvitedDeviceMonitor">
- <arg type="i" name="start" direction="in" />
- <arg type="i" name="result" direction="out" />
- </method>
<!-- Signal (D-Bus) definitions -->
- <signal name="GroupFound">
- <arg type="a{sv}" name="group_info" direction="out" />
- </signal>
- <signal name="GroupFindFinish">
+ <signal name="Event">
+ <arg type="i" name="type" direction="out" />
<arg type="i" name="result" direction="out" />
- </signal>
- <signal name="DeviceFound">
- <arg type="i" name="device_count" direction="out" />
- <arg type="aa{sv}" name="device_info" direction="out" />
- </signal>
- <signal name="DeviceFindFinish">
- <arg type="i" name="result" direction="out" />
- </signal>
- <signal name="DeviceInviteResult">
- <arg type="i" name="result" direction="out" />
- </signal>
- <signal name="DeviceEjectResult">
- <arg type="i" name="result" direction="out" />
- </signal>
- <signal name="MownedDeviceFound">
- <arg type="i" name="device_count" direction="out" />
- <arg type="aa{sv}" name="device_info" direction="out" />
- </signal>
- <signal name="MownedDeviceFindFinish">
- <arg type="i" name="result" direction="out" />
- </signal>
- <signal name="JoinResult">
- <arg type="i" name="result" direction="out" />
- </signal>
- <signal name="SendDataFinish">
- <arg type="s" name="resp_data" direction="out" />
- <arg type="i" name="result" direction="out" />
- </signal>
- <signal name="RequestResult">
- <arg type="s" name="command" direction="out" />
- <arg type="s" name="device_id" direction="out" />
- <arg type="(iay)" name="arg" direction="out" />
- <arg type="i" name="result" direction="out" />
- </signal>
- <signal name="DeviceMonitorResult">
- <arg type="s" name="uuid" direct="out" />
- <arg type="s" name="group_name" direct="out" />
- <arg type="s" name="status" direct="out" />
+ <arg type="a{sv}" name="data" direction="out" />
</signal>
</interface>
</node>
static pthread_mutex_t context_lock = PTHREAD_MUTEX_INITIALIZER;
static mdgd_context_t *mdgd_ctx;
+static void __on_destroy(gpointer data)
+{
+ if (data != NULL)
+ g_free(data);
+}
+
int mdgd_context_create()
{
mdgd_ctx = g_new0(mdgd_context_t, 1);
LOG_DEBUG("create mdgd_context is failed");
return MDGD_ERROR_OUT_OF_MEMORY;
}
- mdgd_ctx->mot_me = FALSE;
- mdgd_ctx->first_search = TRUE;
+
+ mdgd_ctx->mot_me = false;
+ mdgd_ctx->channel = g_hash_table_new_full(g_str_hash, g_str_equal, __on_destroy, __on_destroy);
return MDGD_ERROR_NONE;
}
return -1;
}
- sql = sqlite3_mprintf("CREATE TABLE %s(id INTEGER PRIMARY KEY, device_id TEXT, group_name TEXT);",
+ sql = sqlite3_mprintf("CREATE TABLE %s(id INTEGER PRIMARY KEY, group_name TEXT, device_id TEXT);",
MDGD_DB_DEVICE_TABLE);
if (sql != NULL) {
int mdgd_db_group_insert(const char *group_name)
{
- int ret = 0;
+ int ret = MDGD_ERROR_NONE;
int sql_ret;
char *sql = NULL;
char *error = NULL;
+ LOG_BEGIN();
+
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
if (mdgd_ctx->db == NULL) {
LOG_ERR("mtp_ctx->db is NULL");
- return -1;
+ return MDGD_ERROR_DB;
}
sql = sqlite3_mprintf("INSERT INTO %s (group_name) values(%Q);",
sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
if (sql_ret != SQLITE_OK) {
LOG_ERR("sqlite3_exec failed, %d, %s", sql_ret, error);
- ret = -1;
+ ret = MDGD_ERROR_DB;
sqlite3_free(error);
}
sqlite3_free(sql);
} else {
LOG_ERR("sql is NULL");
- ret = -1;
+ ret = MDGD_ERROR_DB;
}
+ LOG_END();
+
return ret;
}
-int mdgd_db_device_insert(const char *device_id, const char *group_name)
+int mdgd_db_device_insert(const char *group_name, const char *device_id)
{
int ret = 0;
int sql_ret;
char *sql = NULL;
char *error = NULL;
+ LOG_BEGIN();
+
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
if (mdgd_ctx->db == NULL) {
ret = -1;
}
+ LOG_END();
+
return ret;
}
char *sql = NULL;
char *error = NULL;
+ LOG_BEGIN();
+
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
if (mdgd_ctx->db == NULL) {
ret = -1;
}
+ LOG_END();
+
return ret;
}
-int mdgd_db_device_delete(char *device_id, char *group_name)
+int mdgd_db_device_delete(char *group_name, char *device_id)
{
int ret = 0;
int sql_ret;
char *sql = NULL;
char *error = NULL;
+ LOG_BEGIN();
+
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
if (mdgd_ctx->db == NULL) {
}
-bool mdgd_check_device_exist(char *device_id)
+bool mdgd_db_check_device_exist(char *device_id)
{
int ret = 0;
bool result = false;
- int sql_ret;
char *sql = NULL;
+ LOG_BEGIN();
+
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
sql = sqlite3_mprintf("SELECT count(*) FROM %s WHERE device_id=%Q;",
result = false;
}
+ LOG_END();
+
return result;
}
-bool mdgd_check_group_exist(const char *group_name)
+bool mdgd_db_check_device_exist_in_group(char *group_name, char *device_id)
{
int ret = 0;
bool result = false;
char *sql = NULL;
+ LOG_BEGIN();
+
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+ sql = sqlite3_mprintf("SELECT count(*) FROM %s WHERE group_name=%Q and device_id=%Q;",
+ MDGD_DB_DEVICE_TABLE, group_name, device_id);
+ if (sql != NULL) {
+ sqlite3_stmt *stmt = NULL;
+
+ ret = sqlite3_prepare_v2(mdgd_ctx->db, sql, strlen(sql), &stmt, NULL);
+ if (ret == SQLITE_OK) {
+ ret = sqlite3_step(stmt);
+ if (ret == SQLITE_ROW) {
+ int count;
+
+ count = sqlite3_column_int(stmt, 0);
+ if (count > 0)
+ result = true;
+ else
+ result = false;
+ } else {
+ LOG_ERR("sqlite3_step failed, [%d:%s]", ret, sqlite3_errmsg(mdgd_ctx->db));
+
+ result = false;
+ }
+
+ sqlite3_finalize(stmt);
+ } else {
+ LOG_ERR("sqlite3_prepare_v2 failed, [%d:%s]", ret, sqlite3_errmsg(mdgd_ctx->db));
+
+ result = false;
+ }
+
+ sqlite3_free(sql);
+ } else {
+ LOG_ERR("sqlite3_mprintf failed");
+
+ result = false;
+ }
+
+ LOG_END();
+
+ return result;
+}
+
+bool mdgd_db_check_group_exist(const char *group_name)
+{
+ int ret = 0;
+ bool result = false;
+ char *sql = NULL;
+
+ LOG_BEGIN();
+
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
sql = sqlite3_mprintf("SELECT count(*) FROM %s WHERE group_name=%Q;",
result = false;
}
+ LOG_END();
+
return result;
}
-int mdgd_db_print()
+void mdgd_db_get_groups(char **groups, int *group_count)
+{
+ int ret, i = 0;
+ char *sql = NULL;
+
+ LOG_BEGIN();
+
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+ sql = sqlite3_mprintf("SELECT * FROM %s", MDGD_DB_GROUP_TABLE);
+ if (sql != NULL) {
+ sqlite3_stmt *stmt = NULL;
+
+ ret = sqlite3_prepare_v2(mdgd_ctx->db, sql, strlen(sql), &stmt, NULL);
+ if (ret == SQLITE_OK) {
+ while (sqlite3_step(stmt) == SQLITE_ROW) {
+ groups[i++] = g_strdup(sqlite3_column_text(stmt, 1));
+ }
+
+ sqlite3_finalize(stmt);
+ } else {
+ LOG_ERR("sqlite3_prepare_v2 failed, [%d:%s]", ret, sqlite3_errmsg(mdgd_ctx->db));
+ }
+
+ sqlite3_free(sql);
+ } else {
+ LOG_ERR("sqlite3_mprintf failed");
+ }
+
+ *group_count = i;
+
+ LOG_END();
+}
+
+void mdgd_db_get_devices_in_group(char *group_name, char **devices, int *device_count)
+{
+ int ret, i = 0;
+ char *sql = NULL;
+
+ LOG_BEGIN();
+
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+ sql = sqlite3_mprintf("SELECT * FROM %s WHERE group_name=%Q;",
+ MDGD_DB_DEVICE_TABLE, group_name);
+
+ if (sql != NULL) {
+ sqlite3_stmt *stmt = NULL;
+
+ ret = sqlite3_prepare_v2(mdgd_ctx->db, sql, strlen(sql), &stmt, NULL);
+ if (ret == SQLITE_OK) {
+ while (sqlite3_step(stmt) == SQLITE_ROW) {
+ devices[i++] = g_strdup(sqlite3_column_text(stmt, 2));
+ }
+
+ sqlite3_finalize(stmt);
+ } else {
+ LOG_ERR("sqlite3_prepare_v2 failed, [%d:%s]", ret, sqlite3_errmsg(mdgd_ctx->db));
+ }
+
+ sqlite3_free(sql);
+ } else {
+ LOG_ERR("sqlite3_mprintf failed");
+ }
+
+ *device_count = i;
+
+ LOG_END();
+}
+
+
+int mdgd_db_group_print()
{
+ int ret, i = 0;
+ char *sql = NULL;
+
+ LOG_BEGIN();
+
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+ sql = sqlite3_mprintf("SELECT * FROM %s", MDGD_DB_GROUP_TABLE);
+ if (sql != NULL) {
+ sqlite3_stmt *stmt = NULL;
+
+ ret = sqlite3_prepare_v2(mdgd_ctx->db, sql, strlen(sql), &stmt, NULL);
+ if (ret == SQLITE_OK) {
+ while (sqlite3_step(stmt) == SQLITE_ROW) {
+ char *group_name;
+ group_name = g_strdup(sqlite3_column_text(stmt, 1));
+ LOG_DEBUG("%d. %s", ++i, group_name);
+ }
+
+ sqlite3_finalize(stmt);
+ } else {
+ LOG_ERR("sqlite3_prepare_v2 failed, [%d:%s]", ret, sqlite3_errmsg(mdgd_ctx->db));
+ }
+
+ sqlite3_free(sql);
+ } else {
+ LOG_ERR("sqlite3_mprintf failed");
+ }
+
+ LOG_END();
+
+ return 0;
+}
+
+int mdgd_db_device_print()
+{
+ int ret, i = 0;
+ char *sql = NULL;
+
+ LOG_BEGIN();
+
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+ sql = sqlite3_mprintf("SELECT * FROM %s", MDGD_DB_DEVICE_TABLE);
+ if (sql != NULL) {
+ sqlite3_stmt *stmt = NULL;
+
+ ret = sqlite3_prepare_v2(mdgd_ctx->db, sql, strlen(sql), &stmt, NULL);
+ if (ret == SQLITE_OK) {
+ while (sqlite3_step(stmt) == SQLITE_ROW) {
+ char *group_name;
+ char *device_id;
+ group_name = g_strdup(sqlite3_column_text(stmt, 1));
+ device_id = g_strdup(sqlite3_column_text(stmt, 2));
+ LOG_DEBUG("%d. %s, %s", ++i, group_name, device_id);
+ }
+
+ sqlite3_finalize(stmt);
+ } else {
+ LOG_ERR("sqlite3_prepare_v2 failed, [%d:%s]", ret, sqlite3_errmsg(mdgd_ctx->db));
+ }
+
+ sqlite3_free(sql);
+ } else {
+ LOG_ERR("sqlite3_mprintf failed");
+ }
+
+ LOG_END();
+
return 0;
}
#include <mdgd_gdbus.h>
#include <sys/types.h>
-
-#define DBUS_SERVICE_DBUS "org.freedesktop.DBus"
-#define DBUS_INTERFACE_DBUS "org.freedesktop.DBus"
+#include <mdgd_group.h>
+#include <mdgd_db.h>
static Group *group_skeleton;
static Enabler *enabler_skeleton;
-Group *group_dbus_get_object()
+gboolean group_create(Group *group, GDBusMethodInvocation *invocation,
+ gchar *group_name, gpointer user_data)
{
- return group_skeleton;
+ gint result = MDGD_ERROR_NONE;
+
+ LOG_BEGIN();
+
+ result = mdgd_group_create(group_name);
+ group_complete_create(group, invocation, result);
+
+ LOG_END();
+
+ return TRUE;
+}
+
+gboolean group_find(Group *group, GDBusMethodInvocation *invocation, gint timeout,
+ gpointer user_data)
+{
+ gint result = MDGD_ERROR_UNKNOWN;
+
+ LOG_BEGIN();
+
+ result = mdgd_group_find(timeout);
+ group_complete_find(group, invocation, result);
+
+ LOG_END();
+
+ return TRUE;
+}
+
+gboolean group_delete(Group *group, GDBusMethodInvocation *invocation,
+ gchar *group_name, gpointer user_data)
+{
+ gint result = MDGD_ERROR_UNKNOWN;
+
+ LOG_BEGIN();
+
+ result = mdgd_group_delete(group_name);
+ group_complete_delete(group, invocation, result);
+
+ LOG_END();
+
+ return TRUE;
+}
+
+gboolean group_find_device(Group *group, GDBusMethodInvocation *invocation,
+ gint timeout, gint is_invited, gpointer user_data)
+{
+ int result = MDGD_ERROR_UNKNOWN;
+
+ LOG_BEGIN();
+
+ result = mdgd_group_find_device(timeout, is_invited);
+ group_complete_find_device(group, invocation, result);
+
+ LOG_END();
+
+ return TRUE;
+}
+
+gboolean group_invite_device(Group *group, GDBusMethodInvocation *invocation, gchar *group_name,
+ gchar *uuid, gchar *pin, gpointer user_data)
+{
+ gint result = MDGD_ERROR_UNKNOWN;
+
+ LOG_BEGIN();
+
+ result = mdgd_group_invite_device(group_name, uuid, pin);
+ group_complete_invite_device(group, invocation, result);
+
+ LOG_END();
+
+ return TRUE;
+}
+
+gboolean group_eject_device(Group *group, GDBusMethodInvocation *invocation, gchar *group_name,
+ gchar *uuid, gpointer user_data)
+{
+ gint result = MDGD_ERROR_UNKNOWN;
+
+ LOG_BEGIN();
+
+ result = mdgd_group_eject_device(group_name, uuid);
+ group_complete_eject_device(group, invocation, result);
+
+ LOG_END();
+
+ return TRUE;
+}
+
+gboolean group_find_channel(Group *group, GDBusMethodInvocation *invocation,
+ gchar *uuid_dev, gchar *addr, int port, GVariant *params,
+ gpointer user_data)
+{
+ LOG_BEGIN();
+ LOG_END();
+}
+
+
+gboolean group_regist_channel(Group *group, GDBusMethodInvocation *invocation,
+ gchar *channel_id, gpointer user_data)
+{
+ int ret = MDGD_ERROR_UNKNOWN;
+
+ LOG_BEGIN();
+
+ const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
+
+ ret = mdgd_group_regist_channel(channel_id, sender);
+
+ group_complete_regist_channel(group, invocation, ret);
+
+ LOG_END();
+
+ return TRUE;
+}
+
+gboolean group_unregist_channel(Group *group, GDBusMethodInvocation *invocation,
+ gchar *channel_id, gpointer user_data)
+{
+ int ret = MDGD_ERROR_UNKNOWN;
+
+ LOG_BEGIN();
+
+ const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
+
+ ret = mdgd_group_unregist_channel(channel_id, sender);
+
+ group_complete_unregist_channel(group, invocation, ret);
+
+ LOG_END();
+
+ return TRUE;
+}
+
+gboolean group_send_data(Group *group, GDBusMethodInvocation *invocation,
+ gchar *uuid_dev, gchar *addr, int port, GVariant *params,
+ gpointer user_data)
+{
+ int ret = MDGD_ERROR_UNKNOWN;
+ 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_data(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_data(uuid_dev, addr, port, data, len);
+
+ group_complete_send_data(group, invocation, 0);
+
+ g_free(data);
+
+ LOG_END();
+
+ return ret;
+}
+
+gboolean group_get_local_device(Group *group,
+ GDBusMethodInvocation *invocation, gpointer user_data)
+{
+ GVariant *device_data;
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+ LOG_BEGIN();
+
+ device_data = mdgd_create_variant_device(mdgd_ctx->device);
+ group_complete_get_local_device(group, invocation, device_data);
+
+ LOG_END();
+
+ return TRUE;
+}
+
+gboolean group_request_create_group(Group *group, GDBusMethodInvocation
+ *invocation, gchar *uuid, gchar *group_name, gpointer user_data)
+{
+ int ret = MDGD_ERROR_UNKNOWN;
+
+ LOG_BEGIN();
+
+ ret = mdgd_group_request_create_group(uuid, group_name);
+ group_complete_request_create_group(group, invocation, ret);
+
+ LOG_END();
+
+ return TRUE;
+}
+
+gboolean group_request_invite(Group *group, GDBusMethodInvocation *invocation,
+ gchar *uuid, gchar *group_name, gchar *target_uuid, gchar *PIN, gpointer user_data)
+{
+ int ret = MDGD_ERROR_UNKNOWN;
+
+ LOG_BEGIN();
+
+ ret = mdgd_group_request_invite(uuid, group_name, target_uuid, PIN);
+ group_complete_request_invite(group, invocation, ret);
+
+ LOG_END();
+
+ return TRUE;
+}
+
+gboolean group_request_eject(Group *group, GDBusMethodInvocation *invocation,
+ gchar *uuid, gchar *group_name, gchar *target_uuid, gpointer user_data)
+{
+ int ret = MDGD_ERROR_UNKNOWN;
+
+ LOG_BEGIN();
+
+ ret = mdgd_group_request_eject(uuid, group_name, target_uuid);
+ group_complete_request_eject(group, invocation, ret);
+
+ LOG_END();
+
+ return TRUE;
+}
+
+void mdgd_gdbus_emit_event(mdgd_event_type_e type, int ret, GVariant *data)
+{
+ LOG_BEGIN();
+
+ group_emit_event(group_skeleton, type, ret, data);
+
+ LOG_END();
}
static bool __group_init(GDBusConnection *connection)
NULL);
g_signal_connect(group_skeleton,
- "handle-get-found-groups",
- G_CALLBACK(group_get_found_groups),
- NULL);
-
- g_signal_connect(group_skeleton,
- "handle-join",
- G_CALLBACK(group_join),
- NULL);
-
- g_signal_connect(group_skeleton,
- "handle-leave",
- G_CALLBACK(group_leave),
- NULL);
-
- g_signal_connect(group_skeleton,
"handle-delete",
G_CALLBACK(group_delete),
NULL);
g_signal_connect(group_skeleton,
- "handle-device-find",
- G_CALLBACK(group_device_find),
- NULL);
-
- g_signal_connect(group_skeleton,
- "handle-invite",
- G_CALLBACK(group_invite),
- NULL);
-
- g_signal_connect(group_skeleton,
- "handle-eject",
- G_CALLBACK(group_eject),
- NULL);
-
- g_signal_connect(group_skeleton,
- "handle-device-invite",
- G_CALLBACK(group_device_invite),
+ "handle-find-device",
+ G_CALLBACK(group_find_device),
NULL);
g_signal_connect(group_skeleton,
- "handle-device-eject",
- G_CALLBACK(group_device_eject),
+ "handle-invite-device",
+ G_CALLBACK(group_invite_device),
NULL);
g_signal_connect(group_skeleton,
- "handle-get-remote-device",
- G_CALLBACK(group_get_remote_device),
+ "handle-eject-device",
+ G_CALLBACK(group_eject_device),
NULL);
g_signal_connect(group_skeleton,
- "handle-pair-resource",
- G_CALLBACK(group_pair_resource),
+ "handle-regist-channel",
+ G_CALLBACK(group_regist_channel),
NULL);
g_signal_connect(group_skeleton,
- "handle-unpair-resource",
- G_CALLBACK(group_unpair_resource),
+ "handle-unregist-channel",
+ G_CALLBACK(group_unregist_channel),
NULL);
g_signal_connect(group_skeleton,
NULL);
g_signal_connect(group_skeleton,
- "handle-find-mowned-devices",
- G_CALLBACK(group_find_mowned_devices),
- NULL);
-
- g_signal_connect(group_skeleton,
- "handle-get-mowned-device",
- G_CALLBACK(group_get_mowned_device),
- NULL);
-
- g_signal_connect(group_skeleton,
- "handle-get-my-mowned-device",
- G_CALLBACK(group_get_my_mowned_device),
- NULL);
-
- g_signal_connect(group_skeleton,
- "handle-get-my-uuid",
- G_CALLBACK(group_get_my_uuid),
+ "handle-get-local-device",
+ G_CALLBACK(group_get_local_device),
NULL);
g_signal_connect(group_skeleton,
G_CALLBACK(group_request_eject),
NULL);
- g_signal_connect(group_skeleton,
- "handle-request-delete-group",
- G_CALLBACK(group_request_delete_group),
- NULL);
-
- g_signal_connect(group_skeleton,
- "handle-start-invited-device-monitor",
- G_CALLBACK(group_start_invited_device_monitor),
- NULL);
-
group = g_dbus_object_manager_server_new(MDGD_DBUS_GROUP_PATH);
// Set connection to 'manager'
mdgd_ctx->ref_count -= 1;
g_dbus_connection_signal_unsubscribe(data->connection, data->conn_id);
+ mdgd_group_unregist_channel(NULL, name);
}
g_free(name);
+++ /dev/null
-/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <mdgd_db.h>
-#include <mdgd_gdbus_group.h>
-
-/* GDBUS Group Layer */
-/* In this gdbus group layer, Please call the "fn_group" service layer function.*/
-
-gboolean group_create(Group *group, GDBusMethodInvocation *invocation,
- gchar *group_name, gpointer user_data)
-{
- gint result = MDGD_ERROR_NONE;
-
- LOG_DEBUG("group create called using dbus successful");
-
- if (mdgd_check_group_exist(group_name))
- LOG_DEBUG("Group already created");
- else {
- result = mdgd_group_create(group_name);
- if (MDGD_ERROR_NONE == result)
- mdgd_db_group_insert(group_name);
- }
-
- group_complete_create(group, invocation, result);
-
- return TRUE;
-}
-
-gboolean group_find(Group *group, GDBusMethodInvocation *invocation, gint timeout,
- gpointer user_data)
-{
- gint result = MDGD_ERROR_UNKNOWN;
-
- LOG_DEBUG("group find called using dbus successful");
-
- result = mdgd_group_find(timeout);
-
- group_complete_find(group, invocation, result);
- return TRUE;
-}
-
-gboolean group_get_found_groups(Group *group, GDBusMethodInvocation *invocation,
- gpointer user_data)
-{
- gint result = MDGD_ERROR_NONE;
- GVariant *group_data;
-
- LOG_DEBUG("get found groups called using dbus successful");
-
- group_data = mdgd_group_get_found_groups();
-
- group_complete_get_found_groups(group, invocation, result, group_data);
- return TRUE;
-}
-
-gboolean group_join(Group *group, GDBusMethodInvocation *invocation,
- gpointer user_data)
-{
- gint result = MDGD_ERROR_UNKNOWN;
-
- LOG_DEBUG("join called using dbus successful");
-
- result = mdgd_group_join();
-
- group_complete_join(group, invocation, result);
-
- return TRUE;
-}
-
-gboolean group_leave(Group *group, GDBusMethodInvocation *invocation,
- gpointer user_data)
-{
- //group_complete_leave(group, invocation, result);
-
- return TRUE;
-}
-
-gboolean group_delete(Group *group, GDBusMethodInvocation *invocation,
- gchar *group_name, gpointer user_data)
-{
- gint result = MDGD_ERROR_INVALID_PARAMETER;
-
- LOG_DEBUG("group delete called using dbus successful");
-
- if (mdgd_check_group_exist(group_name)) {
- LOG_DEBUG("Group %s exists", group_name);
- result = mdgd_group_destroy(group_name);
- if (MDGD_ERROR_NONE == result)
- mdgd_db_group_delete(group_name);
- }
-
- group_complete_delete(group, invocation, result);
-
- return TRUE;
-}
-
-gboolean group_device_find(Group *group, GDBusMethodInvocation *invocation,
- gint timeout, gpointer user_data)
-{
- int result = MDGD_ERROR_UNKNOWN;
-
- result = mdgd_group_find_mot_enabled_devices(timeout);
-
- group_complete_device_find(group, invocation, result);
-
- return TRUE;
-}
-
-gboolean group_device_invite(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid_dev1, gchar *uuid_dev2, gchar *pin, gchar *uri_1, gchar *rt_1,
- gchar *interface_1, int permission_1, gchar *uri_2, gchar *rt_2,
- gchar *interface_2, int permission_2, gpointer user_data)
-{
- gint result = MDGD_ERROR_UNKNOWN;
-
- LOG_DEBUG("group device invite called using dbus successful");
-/*
- result = mdgd_group_invite(uuid_dev1, uuid_dev2, pin, uri_1, rt_1,
- interface_1, permission_1, uri_2, rt_2, interface_2,
- permission_2);
-*/
- group_complete_device_invite(group, invocation, result);
-
- return TRUE;
-}
-
-gboolean group_device_eject(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid_dev1, gchar *uuid_dev2, gpointer user_data)
-{
- gint result = MDGD_ERROR_UNKNOWN;
-
- LOG_DEBUG("group device eject called using dbus successful");
-
- result = mdgd_group_eject(NULL, uuid_dev1, uuid_dev2);
-
- group_complete_device_eject(group, invocation, result);
-
- return TRUE;
-}
-
-gboolean group_invite(Group *group, GDBusMethodInvocation *invocation, gchar *group_name,
- gchar *uuid, gchar *pin, gpointer user_data)
-{
- gint result = MDGD_ERROR_UNKNOWN;
-
- LOG_DEBUG("group invite called using dbus successful");
-
- if (mdgd_check_device_exist(uuid)) {
- result = MDGD_ERROR_ALREADY_REGISTERED;
- } else {
- result = mdgd_group_invite(group_name, uuid, pin);
- if (MDGD_ERROR_NONE == result)
- mdgd_db_device_insert(uuid, group_name);
- }
-
- /* Now, for the sake of convenience, we change 'group_complete_invite' to 'group_complete_device_invite'. */
-#if 0
- group_complete_invite(group, invocation, result);
-#else
- group_complete_device_invite(group, invocation, result);
-#endif
-
- return TRUE;
-}
-
-gboolean group_eject(Group *group, GDBusMethodInvocation *invocation, gchar *group_name,
- gchar *uuid, gpointer user_data)
-{
- gint result = MDGD_ERROR_UNKNOWN;
-
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
- mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx, FALSE);
-
- result = mdgd_group_eject(group_name, mdgd_ctx->device_uuid, uuid);
-
- /* Now, for the sake of convenience, we change 'group_complete_eject' to 'group_complete_device_eject'. */
-#if 0
- group_complete_invite(group, invocation, result);
-#else
- group_complete_device_eject(group, invocation, result);
-#endif
-
- return TRUE;
-}
-
-gboolean group_get_remote_device(Group *group, GDBusMethodInvocation *invocation,
- gpointer user_data)
-{
- int dev_count = 0;
- GVariant *device_data;
-
- LOG_DEBUG("get remote device called using dbus successful");
-
- dev_count = mdgd_group_get_mot_device_count();
- device_data = mdgd_group_get_remote_mot_enabled_devices();
-
- group_complete_get_remote_device(group, invocation, dev_count, device_data);
-
- return TRUE;
-}
-
-gboolean group_pair_resource(Group *group, GDBusMethodInvocation *invocation,
- gchar *target_1, gchar *subject_1, gchar *uri_1, gchar *rt_1,
- gchar *interface_1, int permission_1, gchar *target_2, gchar *subject_2,
- gchar *uri_2, gchar *rt_2, gchar *interface_2, int permission_2,
- gpointer user_data)
-{
- int ret = MDGD_ERROR_UNKNOWN;
-
- LOG_DEBUG("pair resource called using dbus successful");
-
- ret = mdgd_group_pair_resource(target_1, subject_1, uri_1, rt_1,
- interface_1, permission_1, target_2, subject_2, uri_2,
- rt_2, interface_2, permission_2);
-
- group_complete_pair_resource(group, invocation, ret);
-
- return TRUE;
-}
-
-gboolean group_unpair_resource(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid_dev1, gchar *uuid_dev2, gpointer user_data)
-{
- int ret = MDGD_ERROR_UNKNOWN;
-
- LOG_DEBUG("unpair resource called using dbus successful");
-
- ret = mdgd_group_unpair_resource(uuid_dev1, uuid_dev2);
-
- group_complete_unpair_resource(group, invocation, ret);
-
- return TRUE;
-}
-
-gboolean group_send_data(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid_dev, gchar *addr, int port, GVariant *params,
- gpointer user_data)
-{
- int ret = MDGD_ERROR_UNKNOWN;
- int length = 0;
- int len;
- unsigned char *data;
- GVariantIter *iter;
-
- LOG_DEBUG("send data called using dbus successful");
-
- g_variant_get(params, "(iay)", &len, &iter);
-
- data = g_try_malloc0(len + 1);
- if (NULL == data) {
- group_complete_send_data(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_data(uuid_dev, addr, port, data, len);
-
- group_complete_send_data(group, invocation, 0);
-
- g_free(data);
-
- return ret;
-}
-
-gboolean group_find_mowned_devices(Group *group,
- GDBusMethodInvocation *invocation, gint timeout, gpointer user_data)
-{
- int ret = MDGD_ERROR_UNKNOWN;
-
- LOG_DEBUG("find mot owned devices called using dbus successful");
-
- ret = mdgd_group_find_mowned_devices(timeout);
-
- group_complete_find_mowned_devices(group, invocation, ret);
-
- return TRUE;
-}
-
-gboolean group_get_mowned_device(Group *group,
- GDBusMethodInvocation *invocation, gpointer user_data)
-{
- int dev_count = 0;
- GVariant *device_data;
-
- LOG_DEBUG("get mowned device called using dbus successful");
-
- dev_count = mdgd_group_get_mowned_device_count();
- device_data = mdgd_group_get_mowned_devices();
-
- group_complete_get_mowned_device(group, invocation, dev_count, device_data);
-
- return TRUE;
-}
-
-gboolean group_get_my_mowned_device(Group *group,
- GDBusMethodInvocation *invocation, gpointer user_data)
-{
- GVariant *device_data;
-
- LOG_DEBUG("get mowned device called using dbus successful");
-
- device_data = mdgd_group_get_my_mowned_devices();
- LOG_DEBUG("get mowned device called end ");
-
- group_complete_get_my_mowned_device(group, invocation, device_data);
-
- return TRUE;
-}
-
-gboolean group_get_my_uuid(Group *group,
- GDBusMethodInvocation *invocation, gpointer user_data)
-{
- LOG_DEBUG("get my uuid called using dbus successful");
-
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
- group_complete_get_my_uuid(group, invocation, mdgd_ctx->device_uuid);
-
- return TRUE;
-}
-
-gboolean group_request_create_group(Group *group, GDBusMethodInvocation
- *invocation, gchar *uuid, gchar *group_name, gpointer user_data)
-{
- int ret = MDGD_ERROR_UNKNOWN;
-
- LOG_DEBUG("Request Create Group called using dbus successful");
-
- ret = mdgd_group_request_create_group(uuid, group_name);
-
- group_complete_request_create_group(group, invocation, ret);
-
- return TRUE;
-}
-
-gboolean group_request_invite(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gchar *group_name, gchar *target_uuid, gchar *PIN, gpointer user_data)
-{
- int ret = MDGD_ERROR_UNKNOWN;
-
- LOG_DEBUG("Request Invite called using dbus successful");
-
- ret = mdgd_group_request_invite(uuid, group_name, target_uuid, PIN);
-
- group_complete_request_invite(group, invocation, ret);
-
- return TRUE;
-}
-
-gboolean group_request_eject(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gchar *group_name, gchar *target_uuid, gpointer user_data)
-{
- int ret = MDGD_ERROR_UNKNOWN;
-
- LOG_DEBUG("Request Eject called using dbus successful");
-
- ret = mdgd_group_request_eject(uuid, group_name, target_uuid);
-
- group_complete_request_eject(group, invocation, ret);
-
- return TRUE;
-}
-
-gboolean group_request_delete_group(Group *group,
- GDBusMethodInvocation *invocation, gchar *uuid, gchar *group_name, gpointer user_data)
-{
- int ret = MDGD_ERROR_UNKNOWN;
-
- LOG_DEBUG("Request Delete Group called using dbus successful");
-
- ret = mdgd_group_request_delete_group(uuid, group_name);
-
- group_complete_request_delete_group(group, invocation, ret);
-
- return TRUE;
-}
-
-gboolean group_start_invited_device_monitor(Group *group,
- GDBusMethodInvocation *invocation, int start,
- gpointer user_data)
-{
- int ret = MDGD_ERROR_UNKNOWN;
-
- LOG_DEBUG("Start Myowned device monitor");
-
- ret = mdgd_group_start_invited_device_monitor(start);
-
- group_complete_start_invited_device_monitor(group, invocation, ret);
-
- return TRUE;
-}
-
-void notify_group_found(GVariant *group_data)
-{
- group_emit_group_found(group_dbus_get_object(), group_data);
-}
-
-void notify_group_find_finish(int ret)
-{
- group_emit_group_find_finish(group_dbus_get_object(), ret);
-}
-
-void notify_device_found(int device_count, GVariant *device_data)
-{
- group_emit_device_found(group_dbus_get_object(), device_count, device_data);
-}
-
-void notify_device_find_finish(int ret)
-{
- group_emit_device_find_finish(group_dbus_get_object(), ret);
-}
-
-void notify_group_device_invite_result(int ret)
-{
- group_emit_device_invite_result(group_dbus_get_object(), ret);
-}
-
-void notify_group_device_eject_result(int ret)
-{
- group_emit_device_eject_result(group_dbus_get_object(), ret);
-}
-
-void notify_mowned_device_found(int device_count, GVariant *device_data)
-{
- group_emit_mowned_device_found(group_dbus_get_object(), device_count, device_data);
-}
-
-void notify_mowned_device_find_finish(int ret)
-{
- group_emit_mowned_device_find_finish(group_dbus_get_object(), ret);
-}
-void notify_group_join(int result)
-{
- group_emit_join_result(group_dbus_get_object(), result);
-}
-
-void notify_send_data_finish(const char *resp_data, int ret)
-{
- group_emit_send_data_finish(group_dbus_get_object(), resp_data, ret);
-}
-
-void notify_request_result(const char *cmd, const char *requester_id,
- unsigned char *arg, int len, int ret)
-{
- GVariantBuilder *bytearray_builder = NULL;
- GVariant *params = NULL;
- int i;
-
- bytearray_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
-
- for (i = 0; i < len; i++)
- g_variant_builder_add(bytearray_builder, "y", arg[i]);
-
- params = g_variant_new("(iay)", len, bytearray_builder);
- g_variant_builder_unref(bytearray_builder);
-
- group_emit_request_result(group_dbus_get_object(), cmd, requester_id,
- params, ret);
-}
-
-void notify_device_monitor_result(const char *uuid, const char *group_name,
- const char *status)
-{
- group_emit_device_monitor_result(group_dbus_get_object(), uuid, group_name,
- status);
-}
-
*
*/
-#include <mdgd_enum.h>
#include <mdgd_group.h>
#include <mdgd_mot_agent.h>
-#include <mdgd_gdbus_group.h>
#include <mdgd_db.h>
-#include <mdgd_util.h>
+#include <mdgd_context.h>
+#include <mdgd_gdbus.h>
-GList *found_group_list;
-GList *mot_enb_dev_list = NULL;
-GList *mowned_dev_list = NULL;
-GList *invited_dev_list = NULL;
-mdgd_group_invite_info_t *group_invite_info = NULL;
-mdgd_mot_device_t *my_device = NULL;
-
-#define KEEPALIVE_MESSAGE_TIMEOUT 900
-#define CHECK_DEVICE_STATUS_TIMEOUT 3000
-
-/* Called when daemon is start. */
-int mdgd_group_initialize()
-{
- int sql_ret = SQLITE_OK;
- char *sql = NULL;
- sqlite3_stmt *stmt = NULL;
-
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
-
- //1. group creation
- sql = sqlite3_mprintf("SELECT group_name FROM %s;", MDGD_DB_GROUP_TABLE);
- if (sql != NULL) {
- sql_ret = sqlite3_prepare_v2(mdgd_ctx->db, sql, strlen(sql), &stmt, NULL);
- if (sql_ret != SQLITE_OK) {
- LOG_ERR("Error: %s", sqlite3_errmsg(mdgd_ctx->db));
- sqlite3_free(sql);
- return MDGD_ERROR_UNKNOWN;
- }
-
- do {
- char *group_name = NULL;
- sql_ret = sqlite3_step(stmt);
- if (sql_ret != SQLITE_ROW) {
- break;
- }
-
- group_name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
- if (NULL == group_name) {
- LOG_ERR("Memory allocation failed");
- continue;
- }
-
- mdgd_group_create(group_name);
- } while (sql_ret != SQLITE_DONE);
-
- sqlite3_finalize(stmt);
- sqlite3_free(sql);
- }
-
- //2. device creation
- mdgd_group_find_mot_enabled_devices(2);
-
- return MDGD_ERROR_NONE;
-}
-
-void __print_foreach_device(gpointer data, gpointer user_data)
-{
- char *uuid = (char *)data;
- LOG_DEBUG(" - %s", uuid);
-}
-
-void __print_foreach_grp(gpointer data, gpointer user_data)
-{
- mdgd_grp_t *grp = (mdgd_grp_t *)data;
- LOG_DEBUG("Group name : %s", grp->name);
- LOG_DEBUG(" <Device>");
- g_list_foreach(grp->device_list, __print_foreach_device, NULL);
- LOG_DEBUG("");
-}
-
-void __print_groups_information()
-{
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
- mdgd_check_null_ret("mdgd_ctx", mdgd_ctx);
-
- LOG_DEBUG("-------------------------------------------");
- g_list_foreach(mdgd_ctx->grp_list, __print_foreach_grp, NULL);
- LOG_DEBUG("-------------------------------------------");
-}
-
-/* create group and destroy */
int mdgd_group_create(const char* name)
{
- int ret;
+ int ret = MDGD_ERROR_NONE;
LOG_BEGIN();
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx, MDGD_ERROR_INVALID_PARAMETER);
- GList *list = mdgd_ctx->grp_list;
-
- GList *l;
- for (l = list; l != NULL; l = l->next) {
- mdgd_grp_t *grp = (mdgd_grp_t *)l->data;
-
- if (!strncmp(grp->name, name, strlen(grp->name))) {
- LOG_ERR("already exists name in structure");
- return MDGD_ERROR_UNKNOWN;
- }
- }
- ret = mdgd_iot_add_resource(MDGD_RESOURCE_TYPE_GROUP, name);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Add resource is failed : %s", mdgd_log_get_error_string(ret));
- }
-
- mdgd_grp_t *grp = g_new0(mdgd_grp_t, 1);
- grp->name = strdup(name);
-
- mdgd_ctx->grp_list = g_list_append(mdgd_ctx->grp_list, grp);
-
- mdgd_resource_print_list();
- __print_groups_information();
+ if (mdgd_db_check_group_exist(name) == false)
+ ret = mdgd_db_group_insert(name);
+ else
+ ret = MDGD_ERROR_ALREADY_REGISTERED;
LOG_END();
- return MDGD_ERROR_NONE;
+ return ret;
}
-static void _free_group_func(gpointer data)
+int mdgd_group_delete(const char *name)
{
- mdgd_group_t *group = (mdgd_group_t *)data;
- mdgd_check_null_ret("group", group);
-
- if (group->uri_path != NULL) {
- g_free(group->uri_path);
- group->uri_path = NULL;
- }
- if (group->device_id != NULL) {
- g_free(group->device_id);
- group->device_id = NULL;
- }
- if (group->group_name != NULL) {
- g_free(group->group_name);
- group->group_name = NULL;
- }
- if (group->host_addr != NULL) {
- g_free(group->host_addr);
- group->host_addr = NULL;
- }
- if (group->resource_type != NULL) {
- g_free(group->resource_type);
- group->resource_type = NULL;
- }
- g_free(group);
- group = NULL;
-}
+ int ret = MDGD_ERROR_NONE;
+ char *devices[256];
+ int device_count = 0;
-int mdgd_group_destroy(const char* name)
-{
- int ret = MDGD_ERROR_UNKNOWN;
- GList *iter = NULL;
- bool found = FALSE;
- mdgd_grp_t *grp = NULL;
+ LOG_BEGIN();
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
- mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx, -1);
-
- iter = mdgd_ctx->grp_list;
- while (iter != NULL) {
- grp = (mdgd_grp_t *)iter->data;
- if (g_strcmp0(grp->name, name) == 0) {
- GList *device_iter = grp->device_list;
- while (device_iter != NULL) {
- char *device_uuid = (char *)device_iter->data;
- mdgd_group_eject(name, mdgd_ctx->device_uuid, device_uuid);
-
- device_iter = g_list_next(device_iter);
- }
-
- found = TRUE;
- break;
- }
- iter = g_list_next(iter);
- }
- ret = mdgd_iot_delete_resource(MDGD_RESOURCE_TYPE_GROUP, name);
- if (ret == MDGD_ERROR_NONE) {
- LOG_DEBUG("Successfully destroyed group %s", name);
-
- iter = found_group_list;
-
- while (iter != NULL) {
- mdgd_group_t *group = (mdgd_group_t *)iter->data;
- iter = g_list_next(iter);
-
- if (group->type == MDGD_GROUP_GROUP_LOCAL &&
- g_strcmp0(group->group_name, name) == 0) {
- LOG_DEBUG("Remove %s from found group list", name);
- found_group_list = g_list_remove(found_group_list, group);
- _free_group_func(group);
- break;
- }
- }
+ /* Get all device in group */
+ mdgd_db_get_devices_in_group(name, devices, &device_count);
+ for (int i = 0; i < device_count; i++) {
+ mdgd_db_device_delete(name, devices[i]);
- if (found == TRUE)
- mdgd_ctx->grp_list = g_list_remove(mdgd_ctx->grp_list, grp);
+ if (mdgd_db_check_device_exist(devices[i]) == false)
+ agent_unpair(mdgd_ctx->device_uuid, devices[i]);
}
+ /* delete group */
+ mdgd_db_group_delete(name);
+
+ LOG_END();
+
return ret;
}
-
-static void _mot_enb_dev_list_free_func(gpointer data)
+static gboolean __timeout_cb(gpointer data)
{
- mdgd_mot_device_t *device = (mdgd_mot_device_t *)data;
- mdgd_check_null_ret("device", device);
+ int ret = MDGD_ERROR_NONE;
+ mdgd_command_t *cmd = (mdgd_command_t *)data;
+ mdgd_check_null_ret("cmd", cmd);
+ GVariant *dummy = mdgd_create_variant_dummy();
- if (device->device_id != NULL) {
- g_free(device->device_id);
- device->device_id = NULL;
- }
- if (device->addr != NULL) {
- g_free(device->addr);
- device->addr = NULL;
- }
- if (device->route_data != NULL) {
- g_free(device->route_data);
- device->route_data = NULL;
- }
- if (device->remote_id != NULL) {
- g_free(device->remote_id);
- device->remote_id = NULL;
- }
- if (device->sec_ver != NULL) {
- g_free(device->sec_ver);
- device->sec_ver = NULL;
+ LOG_BEGIN();
+
+ if (cmd->resource_type == MDGD_RESOURCE_TYPE_GROUP) {
+ mdgd_gdbus_emit_event(MDGD_EVENT_GROUP_FIND_FINISH, 0, dummy);
+ } else if (cmd->resource_type == MDGD_RESOURCE_TYPE_DEVICE) {
+ mdgd_gdbus_emit_event(MDGD_EVENT_DEVICE_FIND_FINISH, 0, dummy);
+ } else {
+ LOG_ERR("Unknown Resource Type");
}
- g_free(device);
- device = NULL;
+
+ LOG_END();
}
int mdgd_group_find(int timeout)
LOG_BEGIN();
- /* list freeing */
- g_list_free_full(found_group_list, _free_group_func);
- found_group_list = NULL;
-
mdgd_command_t *cmd = g_new0(mdgd_command_t, 1);
mdgd_check_null_ret_error("cmd", cmd, MDGD_ERROR_INVALID_PARAMETER);
+ cmd->resource_type = MDGD_RESOURCE_TYPE_GROUP;
+
ret = mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_GROUP, timeout, cmd);
if (ret != MDGD_ERROR_NONE)
LOG_ERR("Failed to discover resource : %s", mdgd_log_get_error_string(ret));
+ g_timeout_add_seconds(timeout + 1, __timeout_cb, cmd);
+
LOG_END();
return ret;
}
-GVariant *mdgd_group_get_found_groups()
-{
- GVariantBuilder *builder;
- GVariant *group_data;
- GList *iter = NULL;
-
- builder = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}"));
-
- iter = found_group_list;
- while (iter != NULL) {
- mdgd_group_t *group = (mdgd_group_t *)iter->data;
-
- g_variant_builder_open(builder, G_VARIANT_TYPE_VARDICT);
- g_variant_builder_add(builder, "{sv}", "URI",
- g_variant_new_string(group->uri_path));
- g_variant_builder_add(builder, "{sv}", "DeviceID",
- g_variant_new_string(group->device_id));
- g_variant_builder_add(builder, "{sv}", "GroupName",
- g_variant_new_string(group->group_name));
- g_variant_builder_add(builder, "{sv}", "HostAddress",
- g_variant_new_string(group->host_addr));
- g_variant_builder_add(builder, "{sv}", "GroupDeviceType",
- g_variant_new_string(group->resource_type));
- /*When we get found groups, we can get my groups also. */
- g_variant_builder_add(builder, "{sv}", "GroupType",
- g_variant_new_int32(group->type));
- g_variant_builder_close(builder);
-
- iter = g_list_next(iter);
- }
-
- group_data = g_variant_builder_end(builder);
- g_variant_builder_unref(builder);
-
- return group_data;
-}
-
-int mdgd_group_add_new(char *uri_path, char *device_id, char *device_name,
- char *host_addr, char *resource_type, mdgd_group_type_e type)
+int mdgd_group_found(mdgd_group_t *group)
{
- mdgd_group_t *group;
- GVariantBuilder *builder;
GVariant *group_data;
LOG_BEGIN();
- group = g_try_malloc0(sizeof(mdgd_group_t));
- mdgd_check_null_print_error(group, "Memory allocation failed");
+ group_data = mdgd_create_variant_group(group);
- group->uri_path = g_strdup(uri_path);
- group->device_id = g_strdup(device_id);
- group->group_name = g_strdup(device_name);
- group->host_addr = g_strdup(host_addr);
- group->resource_type = g_strdup(resource_type);
- group->type = type;
-
- found_group_list = g_list_append(found_group_list, group);
-
- builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
-
- g_variant_builder_add(builder, "{sv}", "URI",
- g_variant_new_string(group->uri_path));
- g_variant_builder_add(builder, "{sv}", "DeviceID",
- g_variant_new_string(group->device_id));
- g_variant_builder_add(builder, "{sv}", "GroupName",
- g_variant_new_string(group->group_name));
- g_variant_builder_add(builder, "{sv}", "HostAddress",
- g_variant_new_string(group->host_addr));
- g_variant_builder_add(builder, "{sv}", "GroupDeviceType",
- g_variant_new_string(group->resource_type));
- g_variant_builder_add(builder, "{sv}", "GroupType",
- g_variant_new_int32(group->type));
-
- group_data = g_variant_builder_end(builder);
-
- notify_group_found(group_data);
-
- g_variant_builder_unref(builder);
+ mdgd_gdbus_emit_event(MDGD_EVENT_GROUP_FOUND, 0, group_data);
LOG_END();
return MDGD_ERROR_NONE;
}
-/* Join the remote devices in my daemon */
-
-// Find MOT enabled devices
-int mdgd_group_add_new_mot_device(mdgd_mot_device_t *device)
+int mdgd_group_find_device(int timeout, bool is_invited)
{
- GList *iter = NULL;
- gboolean is_exist = FALSE;
+ int ret;
LOG_BEGIN();
- iter = mot_enb_dev_list;
- while (iter != NULL) {
- mdgd_mot_device_t *temp = (mdgd_mot_device_t *)iter->data;
+ mdgd_command_t *cmd = g_new0(mdgd_command_t, 1);
+ mdgd_check_null_ret_error("cmd", cmd, MDGD_ERROR_INVALID_PARAMETER);
+ cmd->resource_type = MDGD_RESOURCE_TYPE_DEVICE;
- if (g_strcmp0(temp->device_id, device->device_id) == 0) {
- LOG_DEBUG("Device %s already exists in mot enable device list",
- device->device_id);
- is_exist = TRUE;
- break;
- }
+ if (is_invited == false)
+ ret = agent_find_mot_enable_devices(timeout);
+ else
+ ret = agent_find_mowned_devices(timeout);
- iter = g_list_next(iter);
+ if (ret != MDGD_ERROR_NONE) {
+ LOG_ERR("Failed to find device : %s",
+ mdgd_log_get_error_string(ret));
}
- if (is_exist == FALSE) {
- LOG_DEBUG("Add device with uuid %s to mot enabled device list",
- device->device_id);
- mot_enb_dev_list = g_list_append(mot_enb_dev_list, device);
- }
+ g_timeout_add_seconds(timeout + 1, __timeout_cb, cmd);
LOG_END();
- return is_exist;
-}
-
-
-GVariant *mdgd_group_get_remote_mot_enabled_devices()
-{
- GVariantBuilder *builder;
- GVariant *group_data;
- GList *iter = NULL;
-
- mdgd_remove_ip_info();
- mdgd_make_ip_info();
-
- builder = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}"));
-
- iter = mot_enb_dev_list;
- while (iter != NULL) {
- mdgd_mot_device_t *device = (mdgd_mot_device_t *)iter->data;
-
- g_variant_builder_open(builder, G_VARIANT_TYPE_VARDICT);
- g_variant_builder_add(builder, "{sv}", "DeviceID",
- g_variant_new_string(device->device_id));
- g_variant_builder_add(builder, "{sv}", "Adapter",
- g_variant_new_int32(device->adapter));
- g_variant_builder_add(builder, "{sv}", "Flags",
- g_variant_new_int32(device->flags));
- g_variant_builder_add(builder, "{sv}", "Port",
- g_variant_new_uint16(device->port));
- g_variant_builder_add(builder, "{sv}", "Address",
- g_variant_new_string(device->addr));
- g_variant_builder_add(builder, "{sv}", "DeviceType",
- g_variant_new_uint16(mdgd_is_local_ip(device->addr)));
- g_variant_builder_add(builder, "{sv}", "Ifindex",
- g_variant_new_int32(device->ifindex));
- g_variant_builder_add(builder, "{sv}", "RouteData",
- g_variant_new_string(device->route_data));
- g_variant_builder_add(builder, "{sv}", "ConnType",
- g_variant_new_int32(device->conn_type));
- g_variant_builder_add(builder, "{sv}", "SecurePort",
- g_variant_new_uint16(device->secure_port));
- g_variant_builder_add(builder, "{sv}", "TcpPort",
- g_variant_new_uint16(device->tcp_port));
- g_variant_builder_add(builder, "{sv}", "SecVer",
- g_variant_new_string(device->sec_ver));
- g_variant_builder_add(builder, "{sv}", "DeviceStatus",
- g_variant_new_int32(device->dev_status));
- LOG_DEBUG("%s", device->model_name);
- g_variant_builder_add(builder, "{sv}", "ModelName",
- g_variant_new_string(device->model_name));
- g_variant_builder_add(builder, "{sv}", "DeviceName",
- g_variant_new_string(device->device_name));
- g_variant_builder_add(builder, "{sv}", "PlatformVer",
- g_variant_new_string(device->platform_ver));
- g_variant_builder_add(builder, "{sv}", "VendorID",
- g_variant_new_string(device->vendor_id));
- g_variant_builder_add(builder, "{sv}", "Profile",
- g_variant_new_string(device->profile));
-
- g_variant_builder_close(builder);
-
- iter = g_list_next(iter);
- }
-
- group_data = g_variant_builder_end(builder);
- g_variant_builder_unref(builder);
-
- return group_data;
-}
-
-int mdgd_group_get_mot_device_count()
-{
- if (mot_enb_dev_list)
- return g_list_length(mot_enb_dev_list);
-
- return 0;
+ return ret;
}
-void mdgd_group_notify_mot_enable_device_done()
+int mdgd_group_found_device(mdgd_device_t *device)
{
GVariant *device_data;
- int count = mdgd_group_get_mot_device_count();
-
- LOG_BEGIN();
-
- device_data = mdgd_group_get_remote_mot_enabled_devices();
-
- notify_device_found(count, device_data);
-
- LOG_END();
-}
-
-int mdgd_group_find_mot_enabled_devices(int timeout)
-{
- int ret;
LOG_BEGIN();
- /* list freeing */
- g_list_free_full(mot_enb_dev_list, _mot_enb_dev_list_free_func);
- mot_enb_dev_list = NULL;
+ device_data = mdgd_create_variant_device(device);
- ret = agent_find_mot_enable_devices(timeout);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to find mot enable devices : %s",
- mdgd_log_get_error_string(ret));
- }
+ mdgd_gdbus_emit_event(MDGD_EVENT_DEVICE_FOUND, 0, device_data);
LOG_END();
- return ret;
+ return MDGD_ERROR_NONE;
}
-void mdgd_group_notify_keepalive_response(mdgd_command_t *cmd)
-{
- GList *iter = NULL;
- gboolean is_exist = FALSE;
- mdgd_invited_device_t *temp;
-
- LOG_DEBUG("Response received from uuid %s", cmd->uuid);
-
- iter = invited_dev_list;
- while (iter != NULL) {
- temp = (mdgd_invited_device_t *)iter->data;
-
- if ((g_strcmp0(temp->group_name, cmd->arg1) == 0) &&
- (g_strcmp0(temp->uuid, cmd->uuid) == 0)) {
- LOG_DEBUG("Device %s count %d found in invited device list",
- cmd->uuid, temp->count);
- is_exist = TRUE;
- break;
- }
-
- iter = g_list_next(iter);
- }
-
- if (is_exist == TRUE)
- temp->count += 1;
-}
+#define FULL_PERMISSION 31
-int mdgd_group_request_keepalive(char *uuid, char *group_name, char *host)
+int mdgd_group_invite_device(const char *group_name, const char *uuid, const char *pin)
{
int ret = MDGD_ERROR_NONE;
- LOG_DEBUG("[Request KeepAlive] to %s", uuid);
- mdgd_command_t *cmd = g_new0(mdgd_command_t, 1);
- cmd->command = MDGD_REQ_KEEP_ALIVE;
- cmd->uuid = g_strdup(uuid);
- cmd->arg1 = g_strdup(group_name);
- cmd->host = g_strdup(host);
-
- ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 2, cmd);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to send data : %s",
- mdgd_log_get_error_string(ret));
- return ret;
- }
-
- return 0;
-}
-
-mdgd_group_invite_info_t *mdgd_group_get_invite_info()
-{
- return group_invite_info;
-}
-
-void mdgd_group_free_invite_info()
-{
- LOG_DEBUG("Remove Group Invite Information %p", group_invite_info);
-
- if (group_invite_info) {
- g_free(group_invite_info->group_name);
- g_free(group_invite_info->uuid_dev1);
- g_free(group_invite_info->uuid_dev2);
- g_free(group_invite_info->pin);
- g_free(group_invite_info->uri_1);
- g_free(group_invite_info->rt_1);
- g_free(group_invite_info->interface_1);
- g_free(group_invite_info->uri_2);
- g_free(group_invite_info->rt_2);
- g_free(group_invite_info->interface_2);
- g_free(group_invite_info);
-
- group_invite_info = NULL;
- }
-}
-
-mdgd_mot_device_t *mdgd_group_check_device_in_mot_enb_dev_list(char *uuid)
-{
- mdgd_mot_device_t *device;
- GList *iter;
-
- iter = mot_enb_dev_list;
+ LOG_BEGIN();
- while (iter != NULL) {
- device = (mdgd_mot_device_t *)iter->data;
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+ mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx, MDGD_ERROR_INVALID_PARAMETER);
- if (g_strcmp0(device->device_id, uuid) == 0) {
- LOG_DEBUG("Device %s is available in mot enable device list", uuid);
- return device;
+ if (mdgd_db_check_device_exist_in_group(group_name, uuid)) {
+ ret = MDGD_ERROR_ALREADY_REGISTERED;
+ } else {
+ if (mdgd_db_check_device_exist(uuid) == false) {
+ ret = agent_pair(pin, mdgd_ctx->device_uuid, uuid, "/comp/data",
+ "core.comp.data", "oic.if.baseline", FULL_PERMISSION, uuid,
+ mdgd_ctx->device_uuid, "/comp/data", "core.comp.data",
+ "oic.if.baseline", FULL_PERMISSION);
}
- }
- return NULL;
-}
-
-static char *_addr2host(char *addr, int port)
-{
- char ip[50];
- char *percent;
-
- g_strlcpy(ip, addr, strlen(addr) + 1);
-
- /* Remove % from address */
- percent = strchr(ip, '%');
- if (percent)
- percent[0] = '\0';
-
- /* IPv6 Address should be encoded for RFC6874 */
- if (strchr(ip, ':')) /* IPv6 Adress */
- return g_strdup_printf("coaps://[%s%s%s]:%d", ip, "%25",
- percent + 1, port);
- else /* IPv4 Address */
- return g_strdup_printf("coaps://%s:%d", ip, port);
-}
-
-void mdgd_group_notify_group_invite(int ret)
-{
- /*
- * ret = 0 OC_STACK_OK
- * ret = 49 OC_STACK_DUPLICATE_UUID
- */
- if (OC_STACK_OK == ret && group_invite_info) {
- mdgd_invited_device_t *device;
- GList *iter = NULL;
- gboolean is_exist = FALSE;
-
- device = g_try_malloc0(sizeof(mdgd_invited_device_t));
- if (NULL == device) {
- LOG_ERR("Memory allocation failed");
- } else {
- device->group_name = g_strdup(group_invite_info->group_name);
- device->uuid = g_strdup(group_invite_info->uuid_dev2);
-
- iter = invited_dev_list;
- while (iter != NULL) {
- mdgd_invited_device_t *temp = (mdgd_invited_device_t *)iter->data;
-
- if ((g_strcmp0(temp->group_name, device->group_name) == 0) &&
- (g_strcmp0(temp->uuid, device->uuid) == 0)) {
- LOG_DEBUG("Device %s already exists in invited device list",
- temp->uuid);
- is_exist = TRUE;
- break;
- }
-
- iter = g_list_next(iter);
- }
-
- if (is_exist == FALSE) {
- mdgd_mot_device_t *temp;
- temp = mdgd_group_check_device_in_mot_enb_dev_list(device->uuid);
- if (temp)
- device->host = _addr2host(temp->addr, temp->secure_port);
-
- device->count = 0;
- LOG_DEBUG("Add device %s group %s host %s to invited device list",
- device->uuid, device->group_name, device->host);
- invited_dev_list = g_list_prepend(invited_dev_list, device);
-
- mdgd_group_request_keepalive(device->uuid, device->group_name,
- device->host);
-
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
- mdgd_check_null_ret("mdgd_ctx", mdgd_ctx);
-
- if (mdgd_ctx->monitor_started == true) {
- notify_device_monitor_result(device->uuid, device->group_name,
- "Added");
-
- mdgd_group_start_invited_device_monitor(1);
- }
-
- } else {
- g_free(device->uuid);
- g_free(device->group_name);
- g_free(device);
- }
- }
- } else if (OC_STACK_DUPLICATE_UUID == ret) {
- /* Replace error code for CAPI */
- ret = MDGD_ERROR_ALREADY_REGISTERED;
- } else if (OC_STACK_INVALID_PARAM == ret) {
- /* Replace error code for CAPI */
- ret = MDGD_ERROR_OPERATION_FAILED;
+ if (MDGD_ERROR_NONE == ret)
+ mdgd_db_device_insert(group_name, uuid);
}
- mdgd_group_free_invite_info();
-
- notify_group_device_invite_result(ret);
-}
-
-
-#define FULL_PERMISSION 31
-
-int _is_pairwise_uuid(char *uuid)
-{
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
- mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx, -1);
-
- GList *iter = NULL;
-
- iter = mdgd_ctx->pairwise_list;
- while (iter != NULL) {
- char *pairwise_uuid = (char *)iter->data;
-
- if (!strncmp(pairwise_uuid, uuid, strlen(uuid)))
- return 0;
-
- iter = g_list_next(iter);
- }
+ LOG_END();
- return -1;
+ return ret;
}
-int mdgd_group_add_device_in_group(const char *group_name, const char *uuid)
+void mdgd_group_notify_invite_device(int result)
{
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
- mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx, -1);
-
- GList *iter = NULL;
-
- iter = mdgd_ctx->grp_list;
- while (iter != NULL) {
- mdgd_grp_t *group = (mdgd_grp_t *)iter->data;
-
- if (!strncmp(group_name, group->name, strlen(group->name))) {
- GList *device_iter = group->device_list;
- while (device_iter != NULL) {
- char *device_uuid = (char *)device_iter->data;
- if (!strncmp(device_uuid, uuid, strlen(device_uuid)))
- return -1;
-
- device_iter = g_list_next(device_iter);
- }
-
- group->device_list = g_list_append(group->device_list, strdup(uuid));
-
- __print_groups_information();
- return 0;
- }
+ LOG_BEGIN();
- iter = g_list_next(iter);
- }
+ GVariant *dummy = mdgd_create_variant_dummy();
+ mdgd_gdbus_emit_event(MDGD_EVENT_INVITE_DEVICE_FINISH, result, dummy);
- return -1;
+ LOG_END();
}
-//Join to device in group (async)
-int mdgd_group_invite(const char *group_name, const char *uuid, const char *pin)
+int mdgd_group_eject_device(const char *group_name, const char *uuid)
{
int ret = MDGD_ERROR_NONE;
LOG_BEGIN();
+
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx, MDGD_ERROR_INVALID_PARAMETER);
-#ifdef INVITE_EJECT_DEVICE_BY_MULTI_RUN
- /*
- * 1. Perform MOT
- * 2. Discover Mowned devices
- * 3. Pairwise
- */
- LOG_DEBUG("group name : %s, uuid : %s", group_name, uuid);
-
- if (_is_pairwise_uuid(uuid) < 0) {
-
- ret = agent_mot(uuid, pin);
- if (ret == MDGD_ERROR_NONE) {
- group_invite_info = g_try_malloc0(sizeof(mdgd_group_invite_info_t));
- group_invite_info->uuid_dev1 = g_strdup(mdgd_ctx->device_uuid);
- group_invite_info->uuid_dev2 = g_strdup(uuid);
- group_invite_info->pin = g_strdup(pin);
- group_invite_info->uri_1 = g_strdup("/comp/data/1");
- group_invite_info->rt_1 = g_strdup("core.comp.data");
- group_invite_info->interface_1 = g_strdup("oic.if.baseline");
- group_invite_info->permission_1 = FULL_PERMISSION;
- group_invite_info->uri_2 = g_strdup("/comp/data/1");
- group_invite_info->rt_2 = g_strdup("core.comp.data");
- group_invite_info->interface_2 = g_strdup("oic.if.baseline");
- group_invite_info->permission_2 = FULL_PERMISSION;
- }
+ if (mdgd_db_check_device_exist_in_group(group_name, uuid) == false) {
+ ret = MDGD_ERROR_NO_DATA;
+ } else {
+ mdgd_db_device_delete(group_name, uuid);
+ if (mdgd_db_check_device_exist(uuid) == false)
+ ret = agent_unpair(mdgd_ctx->device_uuid, uuid);
}
-#else
- group_invite_info = g_try_malloc0(sizeof(mdgd_group_invite_info_t));
- mdgd_check_null_ret_error("group_invite_info", group_invite_info,
- MDGD_ERROR_OUT_OF_MEMORY);
- group_invite_info->uuid_dev2 = g_strdup(uuid);
- group_invite_info->group_name = g_strdup(group_name);
-
- ret = agent_pair(pin, mdgd_ctx->device_uuid, uuid, "/comp/data/1",
- "core.comp.data", "oic.if.baseline", FULL_PERMISSION, uuid,
- mdgd_ctx->device_uuid, "/comp/data/1", "core.comp.data",
- "oic.if.baseline", FULL_PERMISSION);
-#endif
-
- if (mdgd_group_add_device_in_group(group_name, uuid) < 0)
- return MDGD_ERROR_NONE;
-
LOG_END();
return ret;
}
-void mdgd_group_notify_group_dismiss(int result)
+void mdgd_group_notify_eject_device(int result)
{
- LOG_DEBUG("Notify group eject %d", result);
+ LOG_BEGIN();
- /* Replace error code for CAPI */
- if (OC_STACK_INVALID_PARAM == result)
- result = MDGD_ERROR_ALREADY_REGISTERED;
+ GVariant *dummy = mdgd_create_variant_dummy();
+ mdgd_gdbus_emit_event(MDGD_EVENT_EJECT_DEVICE_FINISH, result, dummy);
- notify_group_device_eject_result(result);
+ LOG_END();
}
-int mdgd_group_remove_device_in_group(char *group_name, char *uuid)
+int mdgd_group_regist_channel(char *channel_id, char *sender)
{
+ int ret = MDGD_ERROR_NONE;
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
- mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx, -1);
-
- GList *iter = NULL;
-
- /* Find the device at every group in list */
- iter = mdgd_ctx->grp_list;
- while (iter != NULL) {
- mdgd_grp_t *group = (mdgd_grp_t *)iter->data;
- if (!strncmp(group_name, group->name, strlen(group_name))) {
- GList *device_iter = group->device_list;
-
- device_iter = g_list_remove_all(device_iter, uuid);
- }
-
- iter = g_list_next(iter);
- }
- mdgd_db_device_delete(uuid, group_name);
- __print_groups_information();
-
- return 0;
-}
-
-//dismiss from group (async)
-int mdgd_group_eject(const gchar *group_name, gchar *uuid_dev1, const gchar *uuid_dev2)
-{
- int ret;
LOG_BEGIN();
- #ifdef INVITE_EJECT_DEVICE_BY_MULTI_RUN
- ret = agent_remove_mo_at_device(uuid);
- /*
- * 1. Unpair device
- * 2. Remove MOT at device #2
- * 3. Remove cred at local (device #1)
- * */
-#else
- ret = agent_unpair(uuid_dev1, uuid_dev2);
-#endif
- mdgd_group_remove_device_in_group(group_name, uuid_dev2);
+
+ char *value = g_hash_table_lookup(mdgd_ctx->channel, channel_id);
+ if (value == NULL)
+ g_hash_table_insert(mdgd_ctx->channel, (gpointer)g_strdup(channel_id), (gpointer)g_strdup(sender));
+ else
+ ret = MDGD_ERROR_ALREADY_REGISTERED;
LOG_END();
return ret;
}
-int mdgd_group_pair_resource(char* target1, char *subject1, char *uri1,
- char *rt1, char *interface1, int permission1, char* target2, char *subject2,
- char *uri2, char *rt2, char *interface2, int permission2)
+gboolean __foreach_hash_table(gpointer key, gpointer value, gpointer user_data)
{
- int ret;
-
- LOG_BEGIN();
-
- ret = agent_resources_pairwise(target1, subject1, uri1, rt1, interface1, permission1,
- target2, subject2, uri2, rt2, interface2, permission2);
-
- LOG_END();
-
- return ret;
+ char *sender = (char *)user_data;
+ if (g_strcmp0(sender, value) == 0)
+ return TRUE;
+ else
+ return FALSE;
}
-int mdgd_group_unpair_resource(gchar *uuid_dev1, gchar *uuid_dev2)
+int mdgd_group_unregist_channel(char *channel_id, char *sender)
{
- int ret;
+ int ret = MDGD_ERROR_NONE;
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
LOG_BEGIN();
- ret = agent_unlink_resources(uuid_dev1, uuid_dev2);
+ if (channel_id == NULL) {
+ int removed_count;
+ removed_count = g_hash_table_foreach_remove(mdgd_ctx->channel,
+ __foreach_hash_table, sender);
+ LOG_DEBUG("removed channel count is %d", removed_count);
+ } else {
+ char *value = g_hash_table_lookup(mdgd_ctx->channel, channel_id);
+ if (value != NULL)
+ g_hash_table_remove(mdgd_ctx->channel, channel_id);
+ else
+ ret = MDGD_ERROR_NO_DATA;
+ }
LOG_END();
cmd->command = MDGD_REQ_SEND_DATA;
cmd->uuid = g_strdup(uuid_dev);
- cmd->host = _addr2host(addr, port);
+ cmd->host = mdgd_addr2host(addr, port, true);
#ifdef SUPPORT_BASE64_ENCODING
cmd->data = g_try_malloc0(len + 1);
return ret;
}
-int mdgd_group_add_new_mowned_device(mdgd_mot_device_t *device)
+void mdgd_group_notify_send_data(int result)
{
- GList *iter = NULL;
- gboolean is_exist = FALSE;
-
LOG_BEGIN();
- iter = mowned_dev_list;
- while (iter != NULL) {
- mdgd_mot_device_t *temp = (mdgd_mot_device_t *)iter->data;
-
- if (g_strcmp0(temp->device_id, device->device_id) == 0) {
- LOG_DEBUG("Device %s already exists in mowned device list",
- device->device_id);
- is_exist = TRUE;
- break;
- }
-
- iter = g_list_next(iter);
- }
-
- if (is_exist == FALSE) {
- LOG_DEBUG("Add device with uuid %s to mowned device list",
- device->device_id);
- mowned_dev_list = g_list_append(mowned_dev_list, device);
- }
+ GVariant *dummy = mdgd_create_variant_dummy();
+ mdgd_gdbus_emit_event(MDGD_EVENT_SEND_DATA_FINISH, result, dummy);
LOG_END();
-
- return is_exist;
}
-GVariant *mdgd_group_get_mowned_devices()
-{
- GVariantBuilder *builder;
- GVariant *group_data;
- GList *iter = NULL;
-
- mdgd_remove_ip_info();
- mdgd_make_ip_info();
-
- builder = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}"));
-
- iter = mowned_dev_list;
- while (iter != NULL) {
- mdgd_mot_device_t *device = (mdgd_mot_device_t *)iter->data;
-
- g_variant_builder_open(builder, G_VARIANT_TYPE_VARDICT);
- g_variant_builder_add(builder, "{sv}", "DeviceID",
- g_variant_new_string(device->device_id));
- g_variant_builder_add(builder, "{sv}", "Adapter",
- g_variant_new_int32(device->adapter));
- g_variant_builder_add(builder, "{sv}", "Flags",
- g_variant_new_int32(device->flags));
- g_variant_builder_add(builder, "{sv}", "Port",
- g_variant_new_uint16(device->port));
- g_variant_builder_add(builder, "{sv}", "Address",
- g_variant_new_string(device->addr));
- g_variant_builder_add(builder, "{sv}", "DeviceType",
- g_variant_new_uint16(mdgd_is_local_ip(device->addr)));
- g_variant_builder_add(builder, "{sv}", "Ifindex",
- g_variant_new_int32(device->ifindex));
- g_variant_builder_add(builder, "{sv}", "RouteData",
- g_variant_new_string(device->route_data));
- g_variant_builder_add(builder, "{sv}", "ConnType",
- g_variant_new_int32(device->conn_type));
- g_variant_builder_add(builder, "{sv}", "SecurePort",
- g_variant_new_uint16(device->secure_port));
- g_variant_builder_add(builder, "{sv}", "TcpPort",
- g_variant_new_uint16(device->tcp_port));
- g_variant_builder_add(builder, "{sv}", "SecVer",
- g_variant_new_string(device->sec_ver));
- g_variant_builder_add(builder, "{sv}", "DeviceStatus",
- g_variant_new_int32(device->dev_status));
- g_variant_builder_add(builder, "{sv}", "ModelName",
- g_variant_new_string(device->model_name));
- g_variant_builder_add(builder, "{sv}", "DeviceName",
- g_variant_new_string(device->device_name));
- g_variant_builder_add(builder, "{sv}", "PlatformVer",
- g_variant_new_string(device->platform_ver));
- g_variant_builder_add(builder, "{sv}", "VendorID",
- g_variant_new_string(device->vendor_id));
- g_variant_builder_add(builder, "{sv}", "Profile",
- g_variant_new_string(device->profile));
-
- g_variant_builder_close(builder);
-
- iter = g_list_next(iter);
- }
-
- group_data = g_variant_builder_end(builder);
- g_variant_builder_unref(builder);
-
- return group_data;
-}
-
-void mdgd_group_change_mowned_device(mdgd_mot_device_t *device)
-{
- LOG_BEGIN();
-
- my_device = device;
-
- LOG_END();
-}
-
-GVariant *mdgd_group_get_my_mowned_devices()
-{
- GVariantBuilder *builder;
- GVariant *group_data;
-
- mdgd_remove_ip_info();
- mdgd_make_ip_info();
-
- builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
-
- if (my_device != NULL) {
- g_variant_builder_add(builder, "{sv}", "DeviceID",
- g_variant_new_string(my_device->device_id));
- g_variant_builder_add(builder, "{sv}", "Adapter",
- g_variant_new_int32(my_device->adapter));
- g_variant_builder_add(builder, "{sv}", "Flags",
- g_variant_new_int32(my_device->flags));
- g_variant_builder_add(builder, "{sv}", "Port",
- g_variant_new_uint16(my_device->port));
- g_variant_builder_add(builder, "{sv}", "Address",
- g_variant_new_string(my_device->addr));
- g_variant_builder_add(builder, "{sv}", "DeviceType",
- g_variant_new_uint16(mdgd_is_local_ip(my_device->addr)));
- g_variant_builder_add(builder, "{sv}", "Ifindex",
- g_variant_new_int32(my_device->ifindex));
- g_variant_builder_add(builder, "{sv}", "RouteData",
- g_variant_new_string(my_device->route_data));
- g_variant_builder_add(builder, "{sv}", "ConnType",
- g_variant_new_int32(my_device->conn_type));
- g_variant_builder_add(builder, "{sv}", "SecurePort",
- g_variant_new_uint16(my_device->secure_port));
- g_variant_builder_add(builder, "{sv}", "TcpPort",
- g_variant_new_uint16(my_device->tcp_port));
- g_variant_builder_add(builder, "{sv}", "SecVer",
- g_variant_new_string(my_device->sec_ver));
- g_variant_builder_add(builder, "{sv}", "DeviceStatus",
- g_variant_new_int32(my_device->dev_status));
- g_variant_builder_add(builder, "{sv}", "ModelName",
- g_variant_new_string(my_device->model_name));
- g_variant_builder_add(builder, "{sv}", "DeviceName",
- g_variant_new_string(my_device->device_name));
- g_variant_builder_add(builder, "{sv}", "PlatformVer",
- g_variant_new_string(my_device->platform_ver));
- g_variant_builder_add(builder, "{sv}", "VendorID",
- g_variant_new_string(my_device->vendor_id));
- g_variant_builder_add(builder, "{sv}", "Profile",
- g_variant_new_string(my_device->profile));
- }
-
- group_data = g_variant_builder_end(builder);
- g_variant_builder_unref(builder);
-
- return group_data;
-}
-
-int mdgd_group_get_mowned_device_count()
-{
- if (mowned_dev_list)
- return g_list_length(mowned_dev_list);
-
- return 0;
-}
-
-void mdgd_group_notify_mowned_device_find_done()
-{
- GVariant *device_data;
- int count = g_list_length(mowned_dev_list);
-
- LOG_BEGIN();
-
- device_data = mdgd_group_get_mowned_devices();
-
- notify_mowned_device_found(count, device_data);
-
- LOG_END();
-}
-
-int mdgd_group_find_mowned_devices(int timeout)
-{
- int ret;
-
- LOG_BEGIN();
-
- /* list freeing */
- g_list_free_full(mowned_dev_list, _mot_enb_dev_list_free_func);
- mowned_dev_list = NULL;
-
- ret = agent_find_mowned_devices(timeout);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to find mowned devices : %s",
- mdgd_log_get_error_string(ret));
- }
-
- LOG_END();
-
- return ret;
-}
-
-/* Join to remote device group */
-
-int mdgd_group_join()
-{
- int ret = MDGD_ERROR_NONE;
-
- LOG_BEGIN();
-
-
- LOG_END();
-
- return ret;
-}
-
-int mdgd_group_leave_from(/* callback */) //leave from certain remote group (Async)
-{
- int ret = MDGD_ERROR_NONE;
- return ret;
-}
-
-/* Called when daemon is end. */
-int mdgd_group_deinitialize()
+int mdgd_group_request_create_group(char *uuid,
+ char *group_name)
{
int ret = MDGD_ERROR_NONE;
- return ret;
-}
-
-int mdgd_group_get_group_name(mdgd_group_t *handle, char **name)
-{
- int ret = MDGD_ERROR_NONE;
- NOTUSED(handle);
- NOTUSED(name);
- return ret;
-}
-
-int mdgd_group_get_group_type(mdgd_group_t *handle, int *type)
-{
- int ret = MDGD_ERROR_NONE;
- NOTUSED(handle);
- NOTUSED(type);
- return ret;
-}
-
-int mdgd_group_get_group_device_type(mdgd_group_t *handle)
-{
- int ret = MDGD_ERROR_NONE;
- NOTUSED(handle);
- return ret;
-}
-
-int mdgd_group_get_group_device_id(mdgd_group_t *handle)
-{
- int ret = MDGD_ERROR_NONE;
- NOTUSED(handle);
- return ret;
-}
-
-int mdgd_group_request_create_group(char *uuid, char *group_name)
-{
- int ret = MDGD_ERROR_NONE;
- mdgd_mot_device_t *device;
LOG_ERR("[Request Create Group] %s", group_name);
LOG_ERR("[Request Create Group] to %s", uuid);
cmd->uuid = g_strdup(uuid);
cmd->arg1 = g_strdup(group_name);
- device = mdgd_group_check_device_in_mot_enb_dev_list(uuid);
- if (device) {
- cmd->host = _addr2host(device->addr, device->secure_port);
- ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 5, cmd);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to send data : %s",
- mdgd_log_get_error_string(ret));
- }
- } else {
- ret = mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_DATA, 5, cmd);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to discover resource : %s",
- mdgd_log_get_error_string(ret));
- }
+ LOG_DEBUG("UUID %s host %s", cmd->uuid, cmd->host);
+
+ ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 3, 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 *uuid, char *group_name, char *target_uuid, char *PIN)
+int mdgd_group_request_invite(char *uuid,
+ char *group_name, char *target_uuid, char *PIN)
{
int ret = MDGD_ERROR_NONE;
- mdgd_mot_device_t *device;
LOG_ERR("[Request Invite] %s, %s, %s", group_name, target_uuid, PIN);
LOG_ERR("[Request Invite] to %s", uuid);
cmd->arg2 = g_strdup(target_uuid);
cmd->arg3 = g_strdup(PIN);
- device = mdgd_group_check_device_in_mot_enb_dev_list(uuid);
- if (device) {
- cmd->host = _addr2host(device->addr, device->secure_port);
- ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 5, cmd);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to send data : %s",
- mdgd_log_get_error_string(ret));
- }
- } else {
- ret = mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_DATA, 5, cmd);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to discover resource : %s",
- mdgd_log_get_error_string(ret));
- }
+ LOG_DEBUG("UUID %s host %s", cmd->uuid, cmd->host);
+
+ ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 3, 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 *uuid, char *group_name, char *target_uuid)
+int mdgd_group_request_eject(char *uuid,
+ char *group_name, char *target_uuid)
{
int ret = MDGD_ERROR_NONE;
- mdgd_mot_device_t *device;
LOG_ERR("[Request Eject] %s, %s", group_name, target_uuid);
LOG_ERR("[Request Eject] to %s", uuid);
cmd->arg1 = g_strdup(group_name);
cmd->arg2 = g_strdup(target_uuid);
- device = mdgd_group_check_device_in_mot_enb_dev_list(uuid);
- if (device) {
- cmd->host = _addr2host(device->addr, device->secure_port);
- ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 5, cmd);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to send data : %s",
- mdgd_log_get_error_string(ret));
- }
- } else {
- ret = mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_DATA, 5, cmd);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to discover resource : %s",
- mdgd_log_get_error_string(ret));
- }
- }
-
- return ret;
-
-}
-
-
-int mdgd_group_request_delete_group(char *uuid, char *group_name)
-{
- int ret = MDGD_ERROR_NONE;
- mdgd_mot_device_t *device;
-
- LOG_ERR("[Request Delete Group] %s", group_name);
- LOG_ERR("[Request Delete Group] to %s", uuid);
-
- mdgd_command_t *cmd = g_new0(mdgd_command_t, 1);
- cmd->command = MDGD_REQ_DELETE_GROUP;
- cmd->uuid = g_strdup(uuid);
- cmd->arg1 = g_strdup(group_name);
-
- device = mdgd_group_check_device_in_mot_enb_dev_list(uuid);
- if (device) {
- cmd->host = _addr2host(device->addr, device->secure_port);
- ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 5, cmd);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to send data : %s",
- mdgd_log_get_error_string(ret));
- }
- } else {
- ret = mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_DATA, 5, cmd);
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("Failed to discover resource : %s",
- mdgd_log_get_error_string(ret));
- }
- }
-
- return ret;
-}
-
-static gboolean __send_keepalive_messages(gpointer user_data)
-{
- GList *iter = NULL;
-
- iter = invited_dev_list;
- while (iter != NULL) {
- mdgd_invited_device_t *temp = (mdgd_invited_device_t *)iter->data;
-
- mdgd_group_request_keepalive(temp->uuid, temp->group_name, temp->host);
-
- iter = g_list_next(iter);
- }
-
- return TRUE;
-}
-
-static gboolean __check_invited_device_status(gpointer user_data)
-{
- int *t_id = (int *)user_data;
- GList *iter = NULL;
-
- g_source_remove(*t_id);
- *t_id = 0;
-
- iter = invited_dev_list;
- while (iter != NULL) {
- mdgd_invited_device_t *temp = (mdgd_invited_device_t *)iter->data;
-
- iter = g_list_next(iter);
-
- LOG_DEBUG("uuid %s count %d", temp->uuid, temp->count);
-
- if (temp->count == 0) {
- LOG_DEBUG("Remove device with uuid %s", temp->uuid);
- invited_dev_list = g_list_remove(invited_dev_list, temp);
-
- notify_device_monitor_result(temp->uuid, temp->group_name,
- "Removed");
-
- g_free(temp->host);
- g_free(temp->uuid);
- g_free(temp->group_name);
- g_free(temp);
- } else {
- temp->count = 0;
- }
- }
-
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
- mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx, FALSE);
-
- if (mdgd_ctx->monitor_started == false) {
- g_free(t_id);
- return FALSE;
- }
-
- if (g_list_length(invited_dev_list) == 0) {
- g_free(t_id);
- return FALSE;
- }
-
- *t_id = g_timeout_add(KEEPALIVE_MESSAGE_TIMEOUT, __send_keepalive_messages,
- NULL);
-
- return TRUE;
-}
-
-int mdgd_group_start_invited_device_monitor(int start)
-{
- int *t_id;
+ LOG_DEBUG("UUID %s host %s", cmd->uuid, cmd->host);
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
- mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx,
- MDGD_ERROR_INVALID_PARAMETER);
-
- if (start) { /* Start Monitor */
- mdgd_ctx->monitor_started = true;
- LOG_DEBUG("Start invited device monitor");
- } else { /* Stop Monitor */
- mdgd_ctx->monitor_started = false;
- LOG_DEBUG("Stop invited device monitor");
- return MDGD_ERROR_NONE;
+ ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 3, cmd);
+ if (ret != MDGD_ERROR_NONE) {
+ LOG_ERR("Failed to send data : %s",
+ mdgd_log_get_error_string(ret));
}
- t_id = g_try_malloc0(sizeof(int));
- mdgd_check_null_ret_error(t_id, NULL, MDGD_ERROR_OUT_OF_MEMORY);
-
- *t_id = g_timeout_add(KEEPALIVE_MESSAGE_TIMEOUT, __send_keepalive_messages,
- NULL);
-
- g_timeout_add(CHECK_DEVICE_STATUS_TIMEOUT, __check_invited_device_status,
- t_id);
+ LOG_END();
- return MDGD_ERROR_NONE;
+ return ret;
}
} else if (cmd->resource_type == MDGD_RESOURCE_TYPE_DEVICE) {
if (!strncmp(cmd->arg1, "disc_mot_enb_devs_done", strlen(cmd->arg1))) {
LOG_DEBUG("Device Find Done. notified");
-<<<<<<< HEAD
- mdgd_group_notify_mot_enable_device_done();
- notify_device_find_finish(ret);
-=======
if (mdgd_group_get_mot_device_count() > 0)
ret = 0;
mdgd_group_notify_mot_enable_device_done();
notify_device_find_finish(ret);
}
->>>>>>> Add daemon recovery when daemon is reboot impl
} else {
LOG_DEBUG("MOT Device Find Done. notified");
mdgd_group_notify_mowned_device_find_done();
--- /dev/null
+/*
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <tzplatform_config.h>
+
+#include <utlist.h>
+#include <base64.h>
+#include <sys/utsname.h>
+
+#include <octypes.h>
+#include <pmtypes.h>
+#include <pmutility.h>
+#include <securevirtualresourcetypes.h>
+
+#include <iotivity_config.h>
+#include <platform_features.h>
+#include <ocprovisioningmanager.h>
+#include <doxmresource.h>
+#include <system_info.h>
+#include <vconf.h>
+#include <system_settings.h>
+
+#include <mdgd_iot.h>
+#include <mdgd_group.h>
+#include <mdgd_gdbus.h>
+#include <mdgd_mot_agent.h>
+#include <mdgd_db.h>
+#include <map>
+
+#include "OCProvisioningManager.hpp"
+#include "OCPlatform.h"
+#include "OCApi.h"
+
+using namespace OC;
+using namespace std;
+
+void __get_group_information(const HeaderOptions& headerOptions,
+ const OCRepresentation& rep, const int eCode, void *user_data)
+{
+ int ret;
+
+ LOG_BEGIN();
+
+ try {
+ if (eCode == OC_STACK_OK || eCode == OC_STACK_RESOURCE_CREATED ||
+ eCode == OC_STACK_RESOURCE_CHANGED) {
+ mdgd_check_null_ret("user_data", user_data);
+ mdgd_group_t *group = (mdgd_group_t *)user_data;
+ std::map<std::string, AttributeValue> groups = rep.getValues();
+ std::map<std::string, AttributeValue>::iterator iter;
+
+ for (iter = groups.begin(); iter != groups.end(); ++iter) {
+
+ std::string group_name = (*iter).first;
+ group->group_name = g_strdup(group_name.c_str());
+ LOG_DEBUG("Group Found : %s, Type : %d", group->group_name, group->type);
+
+ mdgd_group_found(group);
+
+ g_free(group->group_name);
+ group->group_name = NULL;
+ }
+ } 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)
+{
+ int ret;
+ char *resource_uri_path;
+ char *resource_host;
+ char *resource_type = NULL;
+ mdgd_group_type_e group_type;
+ std::string resourceURI;
+
+ LOG_BEGIN();
+
+ /* Check timeout error */
+ 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());
+ }
+
+ 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());
+ if (g_strcmp0(resource->sid().c_str(), mdgd_ctx->device_uuid) != 0) {
+ group->type = MDGD_GROUP_TYPE_REMOTE;
+ } else {
+ group->type = MDGD_GROUP_TYPE_LOCAL;
+ }
+
+ resource->get(QueryParamsMap(), std::bind(&__get_group_information,
+ std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, group));
+ }
+ }
+ else {
+ LOG_ERR("Resource is invalid");
+ }
+ }
+ catch(std::exception& e)
+ {
+ LOG_ERR("Exception in foundResource: %s", e.what());
+ }
+
+ LOG_END();
+
+ return TRUE;
+}
+
+int mdgd_iot_discovery_resource(mdgd_resource_type_e resource_type, int timeout,
+ void *user_data)
+{
+ int ret;
+ std::ostringstream requestURI;
+ mdgd_command_t *cmd = (mdgd_command_t *) user_data;
+
+ LOG_BEGIN();
+
+ try {
+ requestURI << OC_RSRVD_WELL_KNOWN_URI << "?rt=" <<
+ mdgd_resource_get_type(resource_type);
+
+ auto found_cb = std::bind (&_found_resource, std::placeholders::_1,
+ cmd);
+
+ // timeout setting
+ 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);
+ }
+ } catch (OCException &e) {
+ LOG_ERR("Failed to find resource %s", e.what());
+ ret = e.code();
+ }
+
+ LOG_DEBUG("find resource : %s", get_error_message(ret));
+
+ LOG_END();
+
+ return ret;
+}
+
+void __get_device_description(const HeaderOptions& headerOptions,
+ const OCRepresentation& rep, const int eCode, void *user_data)
+{
+ int ret;
+
+ LOG_BEGIN();
+
+ try {
+ if (eCode == OC_STACK_OK || eCode == OC_STACK_RESOURCE_CREATED ||
+ eCode == OC_STACK_RESOURCE_CHANGED) {
+ mdgd_check_null_ret("user_data", user_data);
+ mdgd_device_t *device = (mdgd_device_t *)user_data;
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+ std::string modelName;
+ std::string platformVer;
+ std::string Profile;
+ std::string deviceName;
+ std::string vendorID;
+
+ rep.getValue("model_name", modelName);
+ rep.getValue("platform_ver", platformVer);
+ rep.getValue("profile", Profile);
+ rep.getValue("device_name", deviceName);
+ rep.getValue("vendor_id", vendorID);
+
+ device->model_name = g_strdup(modelName.c_str());
+ device->platform_ver = g_strdup(platformVer.c_str());
+ device->profile = g_strdup(Profile.c_str());
+ device->device_name = g_strdup(deviceName.c_str());
+ device->vendor_id = g_strdup(vendorID.c_str());
+
+ LOG_DEBUG("Remote Device Found");
+ device->type = MDGD_DEVICE_TYPE_REMOTE;
+ /* Store device information in data structure */
+ mdgd_group_found_device(device);
+ } 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();
+}
+
+int mdgd_iot_get_device_description(mdgd_device_t *device)
+{
+ std::string uri_path;
+ std::vector<std::string> resource_types = {"core.comp.device"};
+ std::vector<std::string> ifaces = {DEFAULT_INTERFACE};
+ char *host_addr = NULL;
+
+ 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);
+
+ device_resource->get(QueryParamsMap(), std::bind (&__get_device_description, std::placeholders::_1,
+ std::placeholders::_2, std::placeholders::_3, device));
+
+ LOG_END();
+}
+
+static void __send_data_finish(const HeaderOptions&,
+ const OCRepresentation& rep, const int eCode,
+ void *user_data)
+{
+ int ret = MDGD_ERROR_NONE;
+ mdgd_command_t *cmd = (mdgd_command_t *)user_data;
+
+ if (eCode < OC_STACK_OK && eCode > OC_STACK_RESOURCE_CHANGED) {
+ LOG_ERR("__send_data_result : %d", eCode);
+ ret = MDGD_ERROR_IOTIVITY;
+ }
+
+ mdgd_group_notify_send_data(ret);
+
+ //__clean_user_data(cmd);
+}
+
+int mdgd_iot_send_data(mdgd_resource_type_e resource_type, int timeout,
+ 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_DATA:
+#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));
+ LOG_DEBUG("b64BufSize = %d outSize = %d b64Buf = %s",
+ b64BufSize, outSize, b64Buf);
+ g_free(b64Buf);
+#else
+ rep.setValue("data", std::string(cmd->arg1));
+#endif
+ break;
+ case MDGD_REQ_CREATE_GROUP:
+ case MDGD_REQ_DELETE_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;
+ 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;
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <tzplatform_config.h>
+
+#include <utlist.h>
+#include <base64.h>
+#include <sys/utsname.h>
+
+#include <octypes.h>
+#include <pmtypes.h>
+#include <pmutility.h>
+#include <securevirtualresourcetypes.h>
+
+#include <iotivity_config.h>
+#include <platform_features.h>
+#include <ocprovisioningmanager.h>
+#include <doxmresource.h>
+#include <system_info.h>
+#include <vconf.h>
+#include <system_settings.h>
+
+#include <mdgd_iot.h>
+#include <mdgd_group.h>
+#include <mdgd_gdbus.h>
+#include <mdgd_mot_agent.h>
+#include <mdgd_db.h>
+
+#include "OCProvisioningManager.hpp"
+#include "OCPlatform.h"
+#include "OCApi.h"
+
+using namespace OC;
+using namespace std;
+
+OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> request)
+{
+ LOG_BEGIN();
+
+ if (request) {
+ std::string requestType = request->getRequestType();
+ int requestFlag = request->getRequestHandlerFlag();
+ OCRepresentation requestRep = request->getResourceRepresentation();
+ ObservationInfo observationInfo = request->getObservationInfo();
+ std::string resourceUri = request->getResourceUri();
+
+ auto pResponse = std::make_shared<OC::OCResourceResponse>();
+ OCRepresentation responseRep;
+ mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+ LOG_DEBUG("Received request from %s:%d",
+ observationInfo.address.c_str(), observationInfo.port);
+ LOG_DEBUG("Request type %s, flag %x", requestType.c_str(), requestFlag);
+ for (auto& attribute : requestRep) {
+ LOG_DEBUG("%s of type %d with value %s", attribute.attrname().c_str(),
+ attribute.type(),
+ attribute.getValueToString().c_str());
+ }
+
+ if (requestType == "GET") {
+ if (strcmp(resourceUri.c_str(),
+ mdgd_resource_get_uri_prefix(MDGD_RESOURCE_TYPE_DEVICE)) == 0) {
+ char *device_name = NULL;
+ char *model_name = NULL;
+ char *platform_ver = NULL;
+ char *profile = NULL;
+ char *vendor_id = NULL;
+
+ system_settings_get_value_string(SYSTEM_SETTINGS_KEY_DEVICE_NAME, &device_name);
+ system_info_get_platform_string(SYSTEM_INFO_MODEL_NAME, &model_name);
+ system_info_get_platform_string(SYSTEM_INFO_PLATFORM_VERSION, &platform_ver);
+ system_info_get_platform_string(SYSTEM_INFO_PROFILE, &profile);
+
+ responseRep.setValue("model_name", std::string(model_name));
+ responseRep.setValue("platform_ver", std::string(platform_ver));
+ responseRep.setValue("profile", std::string(profile));
+ responseRep.setValue("device_name", std::string(device_name));
+ responseRep.setValue("vendor_id", std::string("6FFF"));
+ } else if (strcmp(resourceUri.c_str(),
+ mdgd_resource_get_uri_prefix(MDGD_RESOURCE_TYPE_GROUP)) == 0) {
+ int group_count;
+ char *groups[256];
+
+ mdgd_db_get_groups(groups, &group_count);
+ for (int i = 0; i < group_count; i++) {
+ LOG_DEBUG("%d. group name : %s", i+1, groups[i]);
+ responseRep.setValue(std::string(groups[i]), "NONE");
+ }
+ } else {
+ LOG_ERR("Unknown Resource URI");
+ }
+ } else if (requestType == "POST") { /* Request Operation */
+ unsigned char *arg = NULL;
+ int arg_len = 0;
+ int result;
+ int cmd;
+ std::string requester_id, group_name, uuid, data;
+#ifdef SUPPORT_BASE64_ENCODING
+ int payload_len;
+ size_t outSize;
+ uint8_t *out;
+ uint32_t len = 0;
+#endif
+ try {
+ 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))
+ 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_DATA:
+ LOG_DEBUG("Receive Data");
+#ifdef SUPPORT_BASE64_ENCODING
+ if (!requestRep.getValue("data", data))
+ LOG_ERR("data 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'
+ */
+ payload_len = strlen(data.c_str()); /* This data may be cliped the last padding 1~2 bytes ('='/'==') */
+
+ LOG_DEBUG("data = %s payload_len = %d", data.c_str(),
+ payload_len);
+
+ outSize = B64DECODE_OUT_SAFESIZE(payload_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(), payload_len, out,
+ outSize, &len)) {
+ LOG_ERR("Base64 decoding failed.");
+ g_free(out);
+ return OC_EH_OK;
+ }
+
+ arg = (unsigned char *) g_try_malloc0(len);
+ memcpy(arg, out, len);
+ arg_len = len;
+
+ g_free(out);
+
+ LOG_DEBUG("Successfully decoded from base64");
+#else
+ 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
+ break;
+ case MDGD_REQ_CREATE_GROUP:
+ LOG_DEBUG("Request create group");
+
+ result = MDGD_ERROR_NONE;
+
+ if (requestRep.getValue("name", group_name)) {
+ LOG_DEBUG("group_name : %s", group_name.c_str());
+ result = mdgd_group_create(group_name.c_str());
+ arg = (unsigned char *) g_strdup(group_name.c_str());
+ arg_len = strlen(group_name.c_str());
+ }
+ 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());
+
+ result = mdgd_group_invite_device(group_name.c_str(),
+ uuid.c_str(), "12341234");
+ arg = (unsigned char *) g_strdup(uuid.c_str());
+ arg_len = strlen(uuid.c_str());
+ 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");
+
+ 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(group_name.c_str(),
+ uuid.c_str());
+ arg = (unsigned char *) g_strdup(uuid.c_str());
+ arg_len = strlen(uuid.c_str());
+ break;
+ default:
+ LOG_ERR("Unknown request command %d", cmd);
+ break;
+ }
+
+ g_free(arg);
+ } catch (std::exception& e) {
+ LOG_ERR("Exceptioin occured %s", e.what());
+ }
+ } 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();
+
+ return OC_EH_OK;
+}
+
+int mdgd_iot_add_resource(mdgd_resource_type_e resource_type, const char *uri)
+{
+ OCResourceHandle resourceHandle;
+ std::string uri_path;
+
+ LOG_BEGIN();
+
+ uri_path = std::string(mdgd_resource_get_uri_prefix(resource_type)) +
+ std::string(uri);
+
+ LOG_DEBUG("[ADD] resource uri is %s", uri_path.c_str());
+
+ OCStackResult result = OCPlatform::registerResource(resourceHandle,
+ uri_path,
+ std::string(mdgd_resource_get_type(resource_type)),
+ std::string(DEFAULT_INTERFACE), &_request_handler,
+ mdgd_resource_get_policies(resource_type));
+ if (result != OC_STACK_OK) {
+ LOG_ERR("Failed to create resource");
+ return MDGD_ERROR_NONE;
+ } else {
+ LOG_DEBUG("Successfully created resource");
+ }
+
+ LOG_END();
+
+ return MDGD_ERROR_NONE;
+}
+
return "MDGD_ERROR_NO_DATA";
case MDGD_ERROR_OPERATION_FAILED:
return "MDGD_ERROR_OPERATION_FAILED";
- case MDGD_ERROR_ALREADY_REGISTERED:
- return "MDGD_ERROR_ALREADY_REGISTERED";
case MDGD_ERROR_IN_PROGRESS:
return "MDGD_ERROR_IN_PROGRESS";
case MDGD_ERROR_COMM_ERROR:
return "MDGD_ERROR_COMM_ERROR";
- case MDGD_ERROR_RX:
- return "MDGD_ERROR_RX";
- case MDGD_ERROR_TX:
- return "MDGD_ERROR_TX";
case MDGD_ERROR_PLUGIN_FAIL:
return "MDGD_ERROR_PLUGIN_FAIL";
case MDGD_ERROR_ALREADY_IN_PROGRESS:
return "MDGD_ERROR_ALREADY_IN_PROGRESS";
- case MDGD_ERROR_ALREADY_INITIALIZED:
- return "MDG_ERROR_ALREADY_INITIALIZED";
default:
return "UNKNOWN";
}
*
*/
-#include <mdgd_util.h>
-#include <mdgd_manager.h>
+#include <mdgd_context.h>
+#include <mdgd_group.h>
+#include <mdgd_resource.h>
+#include <mdgd_gdbus.h>
+#include <mdgd_db.h>
#include <mdgd_mot_agent.h>
int main(int argc, char *argv[])
goto EXIT;
}
- //7. operation mgr initialize
+ //5. operation mgr initialize
ret = agent_dbus_start();
if (ret != MDGD_ERROR_NONE) {
LOG_ERR("MOT agent interface initialize failed : %s",
}
agent_enable();
- //example code
- //6. group mgr initialize
- ret = mdgd_group_initialize();
- if (ret != MDGD_ERROR_NONE) {
- LOG_ERR("COMP group initialize failed : %s", mdgd_log_get_error_string(ret));
- goto EXIT;
- }
-
- //8. g main loop run
+ //7. g main loop run
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx, MDGD_ERROR_INVALID_PARAMETER);
g_main_loop_run(mdgd_ctx->main_loop);
EXIT:
- //9. deinitialize phase
+ //8. deinitialize phase
agent_disable();
ret = agent_dbus_stop();
if (ret != MDGD_ERROR_NONE)
LOG_ERR("MOT agent interface deinitialize failed : %s",
mdgd_log_get_error_string(ret));
- mdgd_remove_ip_info();
-
- ret = mdgd_group_deinitialize();
- if (ret != MDGD_ERROR_NONE)
- LOG_ERR("COMP group deinitialize failed : %s", mdgd_log_get_error_string(ret));
-
ret = mdgd_db_deinit();
if (ret != MDGD_ERROR_NONE)
LOG_ERR("COMP db deinitialize failed : %s", mdgd_log_get_error_string(ret));
* limitations under the License.
*
*/
-#include <stdio.h>
-#include <stdlib.h>
-#include <error.h>
-
-#include <glib.h>
-#include <gio/gio.h>
-
-#include <mdgd_log.h>
-#include <mdgd_enum.h>
+#include <mdgd_context.h>
#include <mdgd_group.h>
#include <mdgd_mot_agent.h>
-#include <mdgd_gdbus_group.h>
#define AGENT_SERVER_NAME "net.ma"
#define AGENT_OBJECT_PATH "/net/ma"
};
struct agent_s agent; /**< MOT agent context */
-#ifdef INVITE_EJECT_DEVICE_BY_MULTI_RUN
-static bool mot_dev2 = false;
-static char *device_uuid1 = NULL;
-static char *device_uuid2 = NULL;
-#endif
-
static int _check_agent_vaild(void)
{
if (NULL == agent.dbus_connection || NULL == agent.gproxy_agent_service) {
return MDGD_ERROR_NONE;
}
-int agent_get_ownerid(char* deviceid)
-{
- GVariant *variant = NULL;
- int result = MDGD_ERROR_NONE;
- GError *error = NULL;
-
- result = _check_agent_vaild();
- if (MDGD_ERROR_NONE != result)
- return result;
-
- variant = g_dbus_proxy_call_sync(agent.gproxy_agent_service, "get_ownerid",
- NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
- if (variant) {
- g_variant_get(variant, "(si)", deviceid, &result);
- LOGD("get_ownerid status 0x%x", result);
- } else if (error) {
- LOGE("Failed DBus call [%s]", error->message);
- g_error_free(error);
- /* Restart mot-agent */
- agent_enable();
- result = MDGD_ERROR_IO_ERROR;
- }
-
- return result;
-}
-
int agent_find_mot_enable_devices(int timeout)
{
GVariant *variant = NULL;
g_variant_new("(ss)", uuid_str, pin), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (variant) {
g_variant_get(variant, "(i)", &result);
- LOGD("mot status 0x%x", result);
- } else if (error) {
- LOGE("Failed DBus call [%s]", error->message);
- g_error_free(error);
- /* Restart mot-agent */
- agent_enable();
- result = MDGD_ERROR_IO_ERROR;
- }
-
- return result;
-}
-
-int agent_resources_pairwise(char* target1, char *subject1, char *uri1,
- char *rt1, char *interface1, int permission1, char* target2, char *subject2, char *uri2,
- char *rt2, char *interface2, int permission2)
-{
- GVariant *variant = NULL;
- int result = MDGD_ERROR_NONE;
- GError *error = NULL;
-
- result = _check_agent_vaild();
- if (MDGD_ERROR_NONE != result)
- return result;
-
- variant = g_dbus_proxy_call_sync(agent.gproxy_agent_service, "pairwise",
- g_variant_new("(sssssisssssi)",
- target1, subject1, uri1, rt1, interface1, permission1,
- target2, subject2, uri2, rt2, interface2, permission2),
- G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
- if (variant) {
- g_variant_get(variant, "(i)", &result);
- LOGD("pairwise status 0x%x", result);
- } else if (error) {
- LOGE("Failed DBus call [%s]", error->message);
- g_error_free(error);
- /* Restart mot-agent */
- agent_enable();
- result = MDGD_ERROR_IO_ERROR;
- }
-
- return result;
-}
-
-int agent_unlink_resources(char* uuid_str1, char *uuid_str2)
-{
- GVariant *variant = NULL;
- int result = MDGD_ERROR_NONE;
- GError *error = NULL;
-
- result = _check_agent_vaild();
- if (MDGD_ERROR_NONE != result)
- return result;
-
- variant = g_dbus_proxy_call_sync(agent.gproxy_agent_service, "unlink",
- g_variant_new("(ss)", uuid_str1, uuid_str2), G_DBUS_CALL_FLAGS_NONE,
- -1, NULL, &error);
- if (variant) {
- g_variant_get(variant, "(i)", &result);
- LOGD("remove_subowner status 0x%x", result);
- } else if (error) {
- LOGE("Failed DBus call [%s]", error->message);
- g_error_free(error);
- /* Restart mot-agent */
- agent_enable();
- result = MDGD_ERROR_IO_ERROR;
- }
-#ifdef INVITE_EJECT_DEVICE_BY_MULTI_RUN
- if (result == MDGD_ERROR_NONE) {
- device_uuid1 = g_strdup(uuid_str1);
- device_uuid2 = g_strdup(uuid_str2);
- }
-#endif
- return result;
-}
-
-int agent_remove_subowner(char* uuid_str)
-{
- GVariant *variant = NULL;
- int result = MDGD_ERROR_NONE;
- GError *error = NULL;
-
- result = _check_agent_vaild();
- if (MDGD_ERROR_NONE != result)
- return result;
-
- variant = g_dbus_proxy_call_sync(agent.gproxy_agent_service, "remove_subowner",
- g_variant_new("(s)", uuid_str), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
- if (variant) {
- g_variant_get(variant, "(i)", &result);
- LOGD("remove_subowner status 0x%x", result);
- } else if (error) {
- LOGE("Failed DBus call [%s]", error->message);
- g_error_free(error);
- /* Restart mot-agent */
- agent_enable();
- result = MDGD_ERROR_IO_ERROR;
- }
-
- return result;
-}
-
-int agent_remove_subowned(char* uuid_str)
-{
- GVariant *variant = NULL;
- int result = MDGD_ERROR_NONE;
- GError *error = NULL;
-
- result = _check_agent_vaild();
- if (MDGD_ERROR_NONE != result)
- return result;
-
- variant = g_dbus_proxy_call_sync(agent.gproxy_agent_service, "remove_device",
- g_variant_new("(s)", uuid_str), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
- if (variant) {
- g_variant_get(variant, "(i)", &result);
- LOGD("remove_cred_cocal status 0x%x", result);
+ if (result != MDGD_ERROR_NONE)
+ LOGD("mot status 0x%x", result);
} else if (error) {
LOGE("Failed DBus call [%s]", error->message);
g_error_free(error);
return proxy;
}
-#ifdef INVITE_EJECT_DEVICE_BY_MULTI_RUN
-static gboolean __perform_agent_pairwise(gpointer data)
-{
- int ret;
-
- mot_dev2 = false;
-
- mdgd_group_invite_info_t *group_invite_info;
-
- group_invite_info = mdgd_group_get_invite_info();
- mdgd_check_null_ret_error("group_invite_info", group_invite_info, FALSE);
-
- ret = agent_pairwise(group_invite_info->uuid_dev1, group_invite_info->uuid_dev2,
- group_invite_info->uri_1, group_invite_info->rt_1,
- group_invite_info->interface_1,
- group_invite_info->permission_1,
- group_invite_info->uuid_dev2, group_invite_info->uuid_dev1,
- group_invite_info->uri_2, group_invite_info->rt_2,
- group_invite_info->interface_2,
- group_invite_info->permission_2);
- if (ret != MDGD_ERROR_NONE)
- mdgd_group_notify_group_invite(ret);
-
- return FALSE;
-}
-
-static gboolean __perform_remove_mot_dev2(gpointer data)
-{
- int ret;
-
- ret = agent_remove_subowner(device_uuid2);
- if (ret != MDGD_ERROR_NONE) {
- mdgd_group_notify_group_dismiss(ret);
- g_free(device_uuid1);
- device_uuid1 = NULL;
- g_free(device_uuid2);
- device_uuid1 = NULL;
- }
-
- return FALSE;
-}
-
-static gboolean __perform_remove_cred_at_local(gpointer data)
-{
- int ret;
-
- ret = agent_remove_subowned(device_uuid2);
- if (ret != MDGD_ERROR_NONE) {
- mdgd_group_notify_group_dismiss(ret);
- g_free(device_uuid1);
- device_uuid1 = NULL;
- g_free(device_uuid2);
- device_uuid1 = NULL;
- }
- return FALSE;
-}
-#endif
-
static void _agent_signal_handler(GDBusConnection *connection,
const gchar *sender_name, const gchar *object_path, const gchar *interface_name,
const gchar *signal_name, GVariant *parameters, gpointer userdata)
{
int result = MDGD_ERROR_NONE;
- mdgd_check_null_ret("userdata", userdata);
- LOG_DEBUG("signal received = %s", signal_name);
+ LOG_BEGIN();
- if (0 == g_strcmp0(signal_name, "subowner_enabled")) {
- g_variant_get(parameters, "(i)", &result);
- LOG_DEBUG("Result : %d", result);
- } else if (0 == g_strcmp0(signal_name, "disc_mot_enb_devs_done") ||
- 0 == g_strcmp0(signal_name, "disc_mowned_devs_done")) {
+ mdgd_check_null_ret("userdata", userdata);
+ LOG_DEBUG("signal received = %s", signal_name);
+ if (0 == g_strcmp0(signal_name, "disc_mot_enb_devs_done") ||
+ 0 == g_strcmp0(signal_name, "disc_mowned_devs_done")) {
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+ GVariant *device_info;
+ GVariantIter *iter = NULL;
mdgd_check_null_ret("mdgd_ctx", mdgd_ctx);
mdgd_check_null_ret("parameters", parameters);
- mdgd_command_t *cmd = g_new0(mdgd_command_t, 1);
- mdgd_check_null_ret("cmd", cmd);
+ /* create device handle from parameter */
+ g_variant_get(parameters, "(aa{sv})", &iter);
+ while ((device_info = g_variant_iter_next_value(iter))) {
+ mdgd_device_t *device;
- cmd->uuid = g_strdup(mdgd_ctx->device_uuid);
- cmd->user_data = (void *)g_variant_ref(parameters);
- cmd->arg1 = g_strdup(signal_name);
+ GVariant *val = g_variant_lookup_value(device_info, "deviceId", G_VARIANT_TYPE_STRING);
+ gsize len = 0;
+ const char *device_id = g_variant_get_string(val, &len);
- /* Start peer-discovery */
- mdgd_iot_discovery_resource(MDGD_RESOURCE_TYPE_DEVICE, 2, cmd);
- LOG_DEBUG("Peer description discovery Start");
+ LOG_DEBUG("!!!Device Found!!!");
- } else if (0 == g_strcmp0(signal_name, "acl_done")) {
- g_variant_get(parameters, "(i)", &result);
- LOG_DEBUG("Result : %d", result);
- } else if (0 == g_strcmp0(signal_name, "cred_done")) {
- g_variant_get(parameters, "(i)", &result);
- LOG_DEBUG("Result : %d", result);
- } else if (0 == g_strcmp0(signal_name, "mot_done")) {
-#ifdef INVITE_EJECT_DEVICE_BY_MULTI_RUN
- mdgd_mot_device_t *device;
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
- mdgd_check_null_ret("mdgd_ctx", mdgd_ctx);
+ if (strcmp(device_id, mdgd_ctx->device_uuid) == 0) {
+ LOG_DEBUG("Already Stored : Skip Local device");
- g_variant_get(parameters, "(i)", &result);
- LOG_DEBUG("Result : %d", result);
+ if (mdgd_ctx->mot_me == false) {
+ agent_mot(mdgd_ctx->device_uuid, "12341234");
+ mdgd_ctx->mot_me = true;
+ }
- if (result != 0 && result != 49 &&
- (mdgd_group_get_invite_info() != NULL))
- mdgd_group_notify_group_invite(result);
+ continue;
+ }
- if (mdgd_ctx && (TRUE == mdgd_ctx->mot_me))
- g_timeout_add(10, __perform_agent_pairwise, NULL);
-#endif
- } else if (0 == g_strcmp0(signal_name, "remove_mo_done")) {
- g_variant_get(parameters, "(i)", &result);
- LOG_DEBUG("Result : %d", result);
-#ifdef INVITE_EJECT_DEVICE_BY_MULTI_RUN
- g_timeout_add(10, __perform_remove_cred_at_local, NULL);
-#endif
- } else if (0 == g_strcmp0(signal_name, "remove_cred_local_done")) {
- g_variant_get(parameters, "(i)", &result);
- LOG_DEBUG("Result : %d", result);
-#ifdef INVITE_EJECT_DEVICE_BY_MULTI_RUN
- mdgd_group_notify_group_dismiss(result);
- g_free(device_uuid1);
- device_uuid1 = NULL;
- g_free(device_uuid2);
- device_uuid1 = NULL;
-#endif
- } else if (0 == g_strcmp0(signal_name, "pairwise_done")) {
- g_variant_get(parameters, "(i)", &result);
- LOG_DEBUG("Result : %d", result);
+ device = (mdgd_device_t *)g_try_malloc0(sizeof(mdgd_device_t));
- if (mdgd_group_get_invite_info() != NULL)
- mdgd_group_notify_group_invite(result);
- } else if (0 == g_strcmp0(signal_name, "unlink_done")) {
- g_variant_get(parameters, "(i)", &result);
- LOG_DEBUG("Result : %d", result);
-#ifdef INVITE_EJECT_DEVICE_BY_MULTI_RUN
- if (result != 0) {
- mdgd_group_notify_group_dismiss(result);
- g_free(device_uuid1);
- device_uuid1 = NULL;
- g_free(device_uuid2);
- device_uuid1 = NULL;
- }
+ LOG_DEBUG("deviceId = %s", device_id);
+ device->device_id = g_strdup(device_id);
- g_timeout_add(10, __perform_remove_mot_dev2, NULL);
-#endif
- } else if (0 == g_strcmp0(signal_name, "pair_done")) {
+ 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;
- g_variant_get(parameters, "(i)", &result);
- LOG_DEBUG("Result : %d", result);
+ 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;
+
+ 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;
- mdgd_group_notify_group_invite(result);
- } else if (0 == g_strcmp0(signal_name, "unpair_done")) {
+ if (!strncmp(signal_name, "disc_mot_enb_devs_done", strlen(signal_name))) {
+ device->is_invited = false;
+ LOG_DEBUG("The device is mot enabled device");
+ } else {
+ device->is_invited = true;
+ LOG_DEBUG("The device is mowned device");
+ }
+ mdgd_iot_get_device_description(device);
+ }
+ } else {
g_variant_get(parameters, "(i)", &result);
LOG_DEBUG("Result : %d", result);
- mdgd_group_notify_group_dismiss(result);
+ if (0 == g_strcmp0(signal_name, "pair_done"))
+ mdgd_group_notify_invite_device(result);
+ else if (0 == g_strcmp0(signal_name, "unpair_done"))
+ mdgd_group_notify_eject_device(result);
}
+
+ LOG_END();
}
static int _subscribe_event()
{
return -1;
}
h->dbus_sub_ids = g_list_append(h->dbus_sub_ids, GUINT_TO_POINTER(id));
- LOG_DEBUG("subscribed for (subowner_enabled) signal %d", id);
/* disc_mot_enb_devs_done */
id = g_dbus_connection_signal_subscribe(h->dbus_connection, NULL, AGENT_SERVER_NAME,
return -1;
}
h->dbus_sub_ids = g_list_append(h->dbus_sub_ids, GUINT_TO_POINTER(id));
- LOG_DEBUG("subscribed for (disc_mot_enb_devs_done) signal %d", id);
/* disc_mowned_devs_done */
id = g_dbus_connection_signal_subscribe(h->dbus_connection, NULL, AGENT_SERVER_NAME,
return -1;
}
h->dbus_sub_ids = g_list_append(h->dbus_sub_ids, GUINT_TO_POINTER(id));
- LOG_DEBUG("subscribed for (disc_mowned_devs_done) signal %d", id);
/* mot_done */
id = g_dbus_connection_signal_subscribe(h->dbus_connection, NULL, AGENT_SERVER_NAME,
return -1;
}
h->dbus_sub_ids = g_list_append(h->dbus_sub_ids, GUINT_TO_POINTER(id));
- LOG_DEBUG("subscribed for (mot_done) signal %d", id);
/* acl_done */
id = g_dbus_connection_signal_subscribe(h->dbus_connection, NULL, AGENT_SERVER_NAME,
return -1;
}
h->dbus_sub_ids = g_list_append(h->dbus_sub_ids, GUINT_TO_POINTER(id));
- LOG_DEBUG("subscribed for (acl_done) signal %d", id);
/*cred_done */
id = g_dbus_connection_signal_subscribe(h->dbus_connection, NULL, AGENT_SERVER_NAME,
return -1;
}
h->dbus_sub_ids = g_list_append(h->dbus_sub_ids, GUINT_TO_POINTER(id));
- LOG_DEBUG("subscribed for (cred_done) signal %d", id);
-
- /*pairwise_done */
- id = g_dbus_connection_signal_subscribe(h->dbus_connection, NULL, AGENT_SERVER_NAME,
- "pairwise_done", AGENT_OBJECT_PATH, NULL,
- G_DBUS_CALL_FLAGS_NONE, _agent_signal_handler, h, NULL);
- if (0 == id) {
- LOG_ERR("g_dbus_connection_signal_subscribe(pairwise_done) Fail(%d)", errno);
- return -1;
- }
- h->dbus_sub_ids = g_list_append(h->dbus_sub_ids, GUINT_TO_POINTER(id));
- LOG_DEBUG("subscribed for (pairwise_done) signal %d", id);
-
- /*unlink_done */
- id = g_dbus_connection_signal_subscribe(h->dbus_connection, NULL, AGENT_SERVER_NAME,
- "unlink_done", AGENT_OBJECT_PATH, NULL,
- G_DBUS_CALL_FLAGS_NONE, _agent_signal_handler, h, NULL);
- if (0 == id) {
- LOG_ERR("g_dbus_connection_signal_subscribe(unlink_done) Fail(%d)", errno);
- return -1;
- }
- h->dbus_sub_ids = g_list_append(h->dbus_sub_ids, GUINT_TO_POINTER(id));
- LOG_DEBUG("subscribed for (unlink_done) signal %d", id);
/* remove_mo_done */
id = g_dbus_connection_signal_subscribe(h->dbus_connection, NULL, AGENT_SERVER_NAME,
return -1;
}
h->dbus_sub_ids = g_list_append(h->dbus_sub_ids, GUINT_TO_POINTER(id));
- LOG_DEBUG("subscribed for (remove_mo_done) signal %d", id);
/* remove_cred_local_done */
id = g_dbus_connection_signal_subscribe(h->dbus_connection, NULL, AGENT_SERVER_NAME,
return -1;
}
h->dbus_sub_ids = g_list_append(h->dbus_sub_ids, GUINT_TO_POINTER(id));
- LOG_DEBUG("subscribed for (remove_cred_local_done) signal %d", id);
/*pair_done */
id = g_dbus_connection_signal_subscribe(h->dbus_connection, NULL, AGENT_SERVER_NAME,
return -1;
}
h->dbus_sub_ids = g_list_append(h->dbus_sub_ids, GUINT_TO_POINTER(id));
- LOG_DEBUG("subscribed for (pair_done) signal %d", id);
/*unpair_done */
id = g_dbus_connection_signal_subscribe(h->dbus_connection, NULL, AGENT_SERVER_NAME,
return -1;
}
h->dbus_sub_ids = g_list_append(h->dbus_sub_ids, GUINT_TO_POINTER(id));
- LOG_DEBUG("subscribed for (unpair_done) signal %d", id);
return 0;
}
LOG_ERR("Invaild parameter");
return;
}
- LOG_DEBUG("[Signal unsubscribe] : %d", id);
g_dbus_connection_signal_unsubscribe(h->dbus_connection, id);
}
static void _unsubscribe_event()
/* resource_type, type, uri, policies */
static mdgd_rd_t mdgd_rds[] = {
- {MDGD_RESOURCE_TYPE_GROUP, "core.comp.group", "/comp/group/",
+ {MDGD_RESOURCE_TYPE_GROUP, "core.comp.group", "/comp/group",
OC_DISCOVERABLE | OC_OBSERVABLE},
{MDGD_RESOURCE_TYPE_DEVICE, "core.comp.device", "/comp/device",
OC_DISCOVERABLE | OC_OBSERVABLE},
- {MDGD_RESOURCE_TYPE_OPERATION, "core.comp.operation", "/comp/operation/",
- OC_DISCOVERABLE | OC_OBSERVABLE},
- {MDGD_RESOURCE_TYPE_DATA, "core.comp.data", "/comp/data/",
+ {MDGD_RESOURCE_TYPE_DATA, "core.comp.data", "/comp/data",
OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE},
};
-int mdgd_resource_append(mdgd_resource_type_e resource_type, const char *uri,
- OCResourceHandle resource)
-{
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
- GList *list = mdgd_ctx->resource_list[resource_type];
-
- //append resource handle / name to list
- mdgd_re_t *element = g_new0(mdgd_re_t, 1);
- element->uri = g_strdup(uri);
- element->resource = resource;
- list = g_list_append(list, element);
-
- mdgd_ctx->resource_list[resource_type] = list;
-
- return 0;
-}
-
char *mdgd_resource_get_type(mdgd_resource_type_e resource_type)
{
return mdgd_rds[resource_type].type;
{
return mdgd_rds[resource_type].policies;
}
-
-void __print_foreach_resource(gpointer data, gpointer user_data)
-{
- mdgd_re_t *re = (mdgd_re_t *)data;
- LOG_DEBUG(" ** uri : %s", re->uri);
-}
-
-void mdgd_resource_print_list()
-{
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
-
- LOG_DEBUG("-------------------Print resource list-----------------------");
-
- for (int i = 0; i < MDGD_RESOURCE_TYPE_MAX; i++) {
- LOG_DEBUG("Resource type %d list length : %d",
- i, g_list_length(mdgd_ctx->resource_list[i]));
- g_list_foreach(mdgd_ctx->resource_list[i], __print_foreach_resource, NULL);
- }
-
- LOG_DEBUG("-------------------Print resource list end-------------------");
-}
-
-OCResourceHandle mdgd_resource_get_handle(mdgd_resource_type_e resource_type,
- const char *uri)
-{
- mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
- GList *list;
-
- LOG_DEBUG("Get Resource handle type %d uri %s", resource_type, uri);
-
- for (list = mdgd_ctx->resource_list[resource_type]; list != NULL;
- list = list->next) {
- mdgd_re_t *re = (mdgd_re_t *)list->data;
- if (g_strcmp0(re->uri, uri) == 0)
- return re->resource;
- }
-
- return NULL;
-}
*
*/
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <net/if.h>
-#include <sys/ioctl.h>
-#include <arpa/inet.h>
-#include <dirent.h>
-#include <glib.h>
-
-#include <mdgd_log.h>
#include <mdgd_util.h>
#define IPV6_ADDR_GLOBAL 0x0000U
}
static void _parse_inet6(const char *ifname) {
- FILE *f = NULL;
+ FILE *f;
int scope, prefix;
- unsigned char ipv6[16] = {0, };
- char dname[IFNAMSIZ + 1] = {0,};
- char address[INET6_ADDRSTRLEN] = {0, };
- char *scopestr = NULL;
+ unsigned char ipv6[16];
+ char dname[IFNAMSIZ];
+ char address[INET6_ADDRSTRLEN];
+ char *scopestr;
f = fopen("/proc/net/if_inet6", "r");
if (f == NULL) {
}
while (19 == fscanf(f," %2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx" \
- "%2hhx%2hhx%2hhx%2hhx%2hhx %*x %x %x %*x %16s",
+ "%2hhx%2hhx%2hhx%2hhx%2hhx %*x %x %x %*x %s",
&ipv6[0], &ipv6[1], &ipv6[2], &ipv6[3], &ipv6[4], &ipv6[5], &ipv6[6], &ipv6[7],
&ipv6[8], &ipv6[9], &ipv6[10], &ipv6[11], &ipv6[12], &ipv6[13], &ipv6[14],
&ipv6[15], &prefix, &scope, dname)) {
- if (strncmp(ifname, dname, IFNAMSIZ) != 0) {
+ if (strcmp(ifname, dname) != 0)
continue;
- }
- if (NULL == inet_ntop(AF_INET6, ipv6, address, sizeof(address)))
+ if (inet_ntop(AF_INET6, ipv6, address, sizeof(address)) == NULL)
continue;
ipv6_info_s *_ipv6 = calloc(1, sizeof(ipv6_info_s));
scopestr = "Unknown";
}
_ipv6->ip = g_strdup(address); /* ex) fe80::212:34ff:fe5a:ec0e */
- if (NULL == _ipv6->ip) {
- LOGE("Memory allocation failed");
- continue;
- }
_ipv6->prefix = prefix; /* ex) 64 */
_ipv6->scope = g_strdup(scopestr); /* Link */
- if (NULL == _ipv6->scope) {
- LOGE("Memory allocation failed");
- continue;
- }
g_ip_info.ipv6_list = g_list_append(g_ip_info.ipv6_list, _ipv6);
}
{
int sock;
struct ifreq ifr;
- struct sockaddr_in *ipaddr = NULL;
- char address[INET_ADDRSTRLEN + 1] = {0,};
+ struct sockaddr_in *ipaddr;
+ char address[INET_ADDRSTRLEN];
size_t ifnamelen;
/* copy ifname to ifr object */
int mdgd_is_local_ip(char *ipdata)
{
char *ip = NULL;
+ char *ifname = NULL;
char *save_str = NULL;
char *addr = NULL;
GList *iter = NULL;
addr = g_strdup(ipdata);
ip = strtok_r(addr, "%", &save_str);
+ ifname = strtok_r(NULL, "%", &save_str);
iter = g_list_first(g_ip_info.ipv6_list);
while (NULL != iter) {
return REMOTE_IP;
}
+char *mdgd_addr2host(char *addr, int port, bool is_secure)
+{
+ char ip[50];
+ char *percent;
+
+ g_strlcpy(ip, addr, strlen(addr) + 1);
+
+ /* Remove % from address */
+ percent = strchr(ip, '%');
+ if (percent)
+ percent[0] = '\0';
+
+ /* IPv6 Address should be encoded for RFC6874 */
+ if (is_secure != true) {
+ if (strchr(ip, ':')) /* IPv6 Adress */
+ return g_strdup_printf("coap://[%s%s%s]:%d", ip, "%25",
+ percent + 1, port);
+ else /* IPv4 Address */
+ return g_strdup_printf("coap://%s:%d", ip, port);
+ } else {
+ if (strchr(ip, ':')) /* IPv6 Adress */
+ return g_strdup_printf("coaps://[%s%s%s]:%d", ip, "%25",
+ percent + 1, port);
+ else /* IPv4 Address */
+ return g_strdup_printf("coaps://%s:%d", ip, port);
+ }
+}
+
+int mdgd_uuid_to_str(const OicUuid_t* uuid, char** strUuid)
+{
+ if (NULL == uuid || NULL == strUuid || NULL != *strUuid) {
+ LOG_ERR("ConvertUuidToStr : Invalid param");
+ return OC_STACK_INVALID_PARAM;
+ }
+
+ size_t uuidIdx = 0;
+ size_t urnIdx = 0;
+ const size_t urnBufSize = (UUID_LENGTH * 2) + 4 + 1;
+ char* convertedUrn = (char*)calloc(urnBufSize, sizeof(char));
+ if (NULL == convertedUrn) {
+ LOG_ERR("Memory Allocation Failed");
+ goto exit;
+ }
+
+ for (uuidIdx = 0, urnIdx = 0; uuidIdx < UUID_LENGTH && urnIdx < urnBufSize;
+ uuidIdx++, urnIdx += 2) {
+ // canonical format for UUID has '8-4-4-4-12'
+ if (uuidIdx == 4 || uuidIdx == 6 || uuidIdx == 8 || uuidIdx == 10) {
+ snprintf(convertedUrn + urnIdx, 2, "%c", '-');
+ urnIdx++;
+ }
+ snprintf(convertedUrn + urnIdx, 3, "%02x", (uint8_t)(uuid->id[uuidIdx]));
+ }
+ convertedUrn[urnBufSize - 1] = '\0';
+
+ *strUuid = convertedUrn;
+ return OC_STACK_OK;
+
+exit:
+ return OC_STACK_NO_MEMORY;
+}
+
+void mdgd_clean_user_data(void *user_data)
+{
+ mdgd_command_t *cmd = (mdgd_command_t *)user_data;
+
+ if (NULL == cmd)
+ return;
+
+ if (cmd->tid) {
+ g_source_remove(cmd->tid);
+ }
+
+ if (cmd->uuid) {
+ 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;
+ }
+ if (cmd->arg2) {
+ g_free(cmd->arg2);
+ cmd->arg2 = NULL;
+ }
+ if (cmd->arg3) {
+ g_free(cmd->arg3);
+ cmd->arg3 = NULL;
+ }
+ if (cmd->arg4) {
+ g_free(cmd->arg4);
+ cmd->arg4 = NULL;
+ }
+
+#ifdef SUPPORT_BASE64_ENCODING
+ if (cmd->data) {
+ g_free(cmd->data);
+ cmd->data = NULL;
+ }
+#endif
+
+ g_free(cmd);
+ cmd = NULL;
+}
+
+GVariant *mdgd_create_variant_group(mdgd_group_t *group)
+{
+ GVariant *data;
+
+ GVariantBuilder *builder;
+
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+
+ 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_new_int32(group->type));
+
+ data = g_variant_builder_end(builder);
+
+ g_variant_builder_unref(builder);
+
+ return data;
+}
+
+GVariant *mdgd_create_variant_device(mdgd_device_t *device)
+{
+ GVariant *data;
+
+ GVariantBuilder *builder;
+
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+
+ g_variant_builder_add(builder, "{sv}", "DeviceID",
+ g_variant_new_string(device->device_id));
+ g_variant_builder_add(builder, "{sv}", "Port",
+ g_variant_new_int32(device->port));
+ g_variant_builder_add(builder, "{sv}", "Addr",
+ g_variant_new_string(device->addr));
+ g_variant_builder_add(builder, "{sv}", "ConnType",
+ g_variant_new_int32(device->conn_type));
+ g_variant_builder_add(builder, "{sv}", "SecurePort",
+ g_variant_new_int32(device->secure_port));
+ g_variant_builder_add(builder, "{sv}", "ModelName",
+ g_variant_new_string(device->model_name));
+ g_variant_builder_add(builder, "{sv}", "DeviceName",
+ g_variant_new_string(device->device_name));
+ g_variant_builder_add(builder, "{sv}", "PlatformVer",
+ g_variant_new_string(device->platform_ver));
+ g_variant_builder_add(builder, "{sv}", "VendorID",
+ g_variant_new_string(device->vendor_id));
+ g_variant_builder_add(builder, "{sv}", "Profile",
+ g_variant_new_string(device->profile));
+ g_variant_builder_add(builder, "{sv}", "IsInvited",
+ g_variant_new_int32(device->is_invited));
+ g_variant_builder_add(builder, "{sv}", "Type",
+ g_variant_new_int32(device->type));
+
+ data = g_variant_builder_end(builder);
+
+ g_variant_builder_unref(builder);
+
+ return data;
+}
+
+GVariant *mdgd_create_variant_dummy()
+{
+ GVariant *data;
+
+ GVariantBuilder *builder;
+
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ data = g_variant_builder_end(builder);
+
+ g_variant_builder_unref(builder);
+
+ return data;
+}
+
projects / platform / core / connectivity / mdg-manager.git / commitdiff