#include <mdgd_util.h>
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
int mdgd_context_create();
#define __MDGD_DB_H__
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
-#include <stdbool.h>
#include <mdgd_typedef.h>
+#include <stdbool.h>
#define MDGD_DB_FILE "/opt/usr/dbspace/.mdgd.db"
#define MDGD_DB_GROUP_TABLE "mdgd_group"
#include <mdgd_context.h>
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
#define MDGD_DBUS_SERVICE "org.tizen.mdg" /**< For mdg dbus */
#define MDGD_DBUS_GROUP_INTERFACE "org.tizen.mdg.group"
-#define MDGD_DBUS_GROUP_PATH "/org/tizen/mdg/group" /**< For group commands */
+#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"
+#define DBUS_SERVICE_DBUS "org.freedesktop.DBus"
+#define DBUS_INTERFACE_DBUS "org.freedesktop.DBus"
void mdgd_gdbus_emit_event(char *sender, mdgd_event_type_e type, int ret, GVariant *data);
int mdgd_gdbus_init();
#include <mdgd_iot.h>
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
/* Group Manangement */
-int mdgd_group_create(const char* name);
-int mdgd_group_delete(char* name);
+int mdgd_group_create(const char *name);
+int mdgd_group_delete(char *name);
int mdgd_group_find(char *sender, int timeout);
int mdgd_group_find_device(char *sender, int timeout, bool is_invited);
-int mdgd_group_invite_device(char *sender, char *group_name,
- mdgd_device_t *device, char *pin);
+int mdgd_group_invite_device(char *sender, char *group_name, mdgd_device_t *device, char *pin);
int mdgd_group_eject_device(char *sender, char *group_name, char *uuid);
int mdgd_group_regist_channel(char *sender, char *channel_id);
int mdgd_group_unregist_channel(char *sender, char *channel_id);
-int mdgd_group_send_data(char *sender, char *uuid, char *channel_id,
- unsigned char *data, int len, int *msg_id);
-int mdgd_group_send_response(char *sender, char *uuid, char *channel_id,
- int msg_id, unsigned char *data, int len);
+int mdgd_group_send_data(char *sender, char *uuid, char *channel_id, unsigned char *data, int len, int *msg_id);
+int mdgd_group_send_response(char *sender, char *uuid, char *channel_id, int msg_id, unsigned char *data, int len);
int mdgd_group_set_preconfigured_pin(char *pin);
/* Group Request to remote */
-int mdgd_group_request(mdgd_request_type_e type, char *sender, char *uuid,
- char *arg1, char *arg2, char *arg3, void *user_data);
+int mdgd_group_request(mdgd_request_type_e type, char *sender, char *uuid, char *arg1, char *arg2, char *arg3, void *user_data);
/* send signal to client */
int mdgd_group_notify_event(char *sender, mdgd_event_type_e type, int result, void *user_data);
-
#ifdef __cplusplus
}
#endif
#ifndef __MDGD_IOT_H__
#define __MDGD_IOT_H__
-#include <mdgd_resource.h>
#include <mdgd_group.h>
+#include <mdgd_resource.h>
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
#define MAX_FILE_PATH_LEN 1024
int mdgd_iot_discovery_resource(mdgd_resource_type_e resource_type, void *user_data);
int mdgd_iot_get_device_description(mdgd_command_t *cmd, char *host_addr, int conn_type);
int mdgd_iot_send_response(char *sender, char *uuid, char *channel_id,
- int msg_id, unsigned char *data, int len, bool timeout);
+ int msg_id, unsigned char *data, int len, bool timeout);
int mdgd_iot_set_preconfigured_pin(char *pin);
int mdgd_iot_remove_subowner(char *subject_id);
int mdgd_iot_deinitialize();
-int mdgd_iot_find_devices(char* sender, int timeout, bool is_invited);
-int mdgd_iot_pair(char *group_name, char *pin, 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_iot_find_devices(char *sender, int timeout, bool is_invited);
+int mdgd_iot_pair(char *group_name, char *pin, 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_iot_unpair(char *group_name, char *subowner_id, char *subowned_id);
#ifdef __cplusplus
#include <mdgd_typedef.h>
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
#ifdef LOG_TAG
#undef LOG_TAG
#endif
-#define COLOR_RED "\033[0;31m"
-#define COLOR_GREEN "\033[0;32m"
-#define COLOR_BROWN "\033[0;33m"
-#define COLOR_BLUE "\033[0;34m"
-#define COLOR_PURPLE "\033[0;35m"
-#define COLOR_CYAN "\033[0;36m"
-#define COLOR_LIGHTBLUE "\033[0;37m"
-#define COLOR_END "\033[0;m"
+#define COLOR_RED "\033[0;31m"
+#define COLOR_GREEN "\033[0;32m"
+#define COLOR_BROWN "\033[0;33m"
+#define COLOR_BLUE "\033[0;34m"
+#define COLOR_PURPLE "\033[0;35m"
+#define COLOR_CYAN "\033[0;36m"
+#define COLOR_LIGHTBLUE "\033[0;37m"
+#define COLOR_END "\033[0;m"
#define LOG_TAG "MDGD"
-#define LOG_DEBUG(fmt, ...) \
- do { \
- LOGD(COLOR_BROWN" " fmt COLOR_END, ##__VA_ARGS__); \
+#define LOG_DEBUG(fmt, ...) \
+ do { \
+ LOGD(COLOR_BROWN " " fmt COLOR_END, ##__VA_ARGS__); \
} while (0)
-#define LOG_ERR(fmt, ...) \
- do { \
- LOGE(COLOR_RED" " fmt COLOR_END, ##__VA_ARGS__); \
+#define LOG_ERR(fmt, ...) \
+ do { \
+ LOGE(COLOR_RED " " fmt COLOR_END, ##__VA_ARGS__); \
} while (0)
-#define LOG_BEGIN() \
- do { \
+#define LOG_BEGIN() \
+ do { \
LOGD(COLOR_BLUE "BEGIN" COLOR_END); \
} while (0)
-#define LOG_END() \
- do { \
+#define LOG_END() \
+ do { \
LOGD(COLOR_BLUE "END" COLOR_END); \
} while (0)
#define NOTUSED(var) (var = var)
-#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; \
- } \
- /* 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; \
+ } \
+ /* 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; \
- } \
- /* 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; \
+ } \
+ /* LCOV_EXCL_STOP */ \
+ } while (FALSE)
const char *mdgd_log_get_error_string(int result);
-const char* mdgd_log_get_iot_error_string(int result);
+const char *mdgd_log_get_iot_error_string(int result);
#ifdef __cplusplus
}
#include <octypes.h>
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
char *mdgd_resource_get_type(mdgd_resource_type_e resource_type);
#ifndef __MDGD_TYPEDEF_H__
#define __MDGD_TYPEDEF_H__
-#include <tizen.h>
-#include <glib.h>
-#include <unistd.h>
+#include <arpa/inet.h>
+#include <dirent.h>
+#include <dlog.h>
+#include <error.h>
#include <gio/gio.h>
+#include <glib.h>
#include <mdg_gdbus.h>
-#include <sys/types.h>
-#include <sys/ioctl.h>
+#include <net/if.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>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <tizen.h>
+#include <unistd.h>
#define NOTUSED(var) (var = var) /**< It is used to avoid generating build warning */
* @since_tizen 5.0
*/
typedef enum {
- MDGD_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
- MDGD_ERROR_IO_ERROR = TIZEN_ERROR_IO_ERROR, /**< I/O error */
+ MDGD_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
+ MDGD_ERROR_IO_ERROR = TIZEN_ERROR_IO_ERROR, /**< I/O error */
MDGD_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
- MDGD_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
+ MDGD_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
MDGD_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */
- MDGD_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */
- MDGD_ERROR_OPERATION_FAILED = TIZEN_ERROR_MDG | 0x01, /**< operation failed */
- MDGD_ERROR_NO_DATA = TIZEN_ERROR_MDG | 0x02, /**< Data not exists */
- MDGD_ERROR_ALREADY_REGISTERED = TIZEN_ERROR_MDG | 0x03, /**< Request already registered */
- MDGD_ERROR_IN_PROGRESS = TIZEN_ERROR_MDG | 0x04,/**< operation is in progress */
- MDGD_ERROR_COMM_ERROR = TIZEN_ERROR_MDG | 0x05, /**< communication error */
- MDGD_ERROR_PLUGIN_FAIL = TIZEN_ERROR_MDG | 0x06, /**< Plugin failed */
- MDGD_ERROR_NOT_STARTED = TIZEN_ERROR_MDG | 0x07, /**< Service Not Started */
- MDGD_ERROR_DB = TIZEN_ERROR_MDG | 0x08, /**< Internal DB error */
+ MDGD_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */
+ MDGD_ERROR_OPERATION_FAILED = TIZEN_ERROR_MDG | 0x01, /**< operation failed */
+ MDGD_ERROR_NO_DATA = TIZEN_ERROR_MDG | 0x02, /**< Data not exists */
+ MDGD_ERROR_ALREADY_REGISTERED = TIZEN_ERROR_MDG | 0x03, /**< Request already registered */
+ MDGD_ERROR_IN_PROGRESS = TIZEN_ERROR_MDG | 0x04, /**< operation is in progress */
+ MDGD_ERROR_COMM_ERROR = TIZEN_ERROR_MDG | 0x05, /**< communication error */
+ MDGD_ERROR_PLUGIN_FAIL = TIZEN_ERROR_MDG | 0x06, /**< Plugin failed */
+ MDGD_ERROR_NOT_STARTED = TIZEN_ERROR_MDG | 0x07, /**< Service Not Started */
+ MDGD_ERROR_DB = TIZEN_ERROR_MDG | 0x08, /**< Internal DB error */
MDGD_ERROR_NETWORK_UNREACHABLE = TIZEN_ERROR_MDG | 0x09,
} mdg_error_e;
typedef enum {
MDGD_RESOURCE_TYPE_GROUP = 0, /**< Group resource type */
- MDGD_RESOURCE_TYPE_DEVICE, /**< Device resource type */
- MDGD_RESOURCE_TYPE_DATA, /**< Data resource type */
+ MDGD_RESOURCE_TYPE_DEVICE, /**< Device resource type */
+ MDGD_RESOURCE_TYPE_DATA, /**< Data resource type */
MDGD_RESOURCE_TYPE_MAX
} mdgd_resource_type_e;
typedef enum {
- MDGD_GROUP_TYPE_LOCAL = 1, /**< Local 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_DEVICE_TYPE_LOCAL = 1, /**< Local group type */
+ MDGD_DEVICE_TYPE_LOCAL = 1, /**< Local group type */
MDGD_DEVICE_TYPE_REMOTE = 2, /**< Remote group type */
} mdgd_device_type_e;
typedef enum {
MDGD_REQ_CREATE_GROUP = 0, /**< Create Group */
- MDGD_REQ_INVITE_DEVICE, /**< Invite Device */
- MDGD_REQ_EJECT_DEVICE, /**< Eject Device */
- MDGD_REQ_CHANNEL_LIST, /**< Channel List */
- MDGD_REQ_SEND_DATA, /**< Send data */
- MDGD_REQ_SEND_FILE, /**< Send File */
+ MDGD_REQ_INVITE_DEVICE, /**< Invite Device */
+ MDGD_REQ_EJECT_DEVICE, /**< Eject Device */
+ MDGD_REQ_CHANNEL_LIST, /**< Channel List */
+ MDGD_REQ_SEND_DATA, /**< Send data */
+ MDGD_REQ_SEND_FILE, /**< Send File */
MDGD_REQ_EVENT_INVITED,
MDGD_REQ_EVENT_EJECTED,
} mdgd_request_type_e;
} mdgd_event_type_e;
typedef struct {
- char *device_id; /**< Device ID */
- char *group_name; /**< Group name */
+ char *device_id; /**< Device ID */
+ char *group_name; /**< Group name */
mdgd_group_type_e type; /**< Group type */
char *sender;
} mdgd_group_t;
typedef struct {
- char *device_id; /**< Device Id */
- char *model_name; /**< Device ID */
- char *device_name; /**< Host address */
+ char *device_id; /**< Device Id */
+ char *model_name; /**< Device ID */
+ char *device_name; /**< Host address */
char *platform_ver; /**< Group name */
- char *vendor_id; /**< Resource type */
- char *profile; /**< Group yype */
+ char *vendor_id; /**< Resource type */
+ char *profile; /**< Group yype */
bool is_invited;
mdgd_device_type_e type; /**< Group type */
} mdgd_device_t;
} mdgd_conn_destroy_data;
typedef struct {
- int resource_type; /**< OCF resource type */
+ int resource_type; /**< OCF resource type */
mdgd_request_type_e type; /**< Comments set for group management */
- gchar *uuid; /**< Device UUID */
- gchar *addr; /**< Host address + Port */
- gchar *sender; /**< Dbus Sender */
- gchar *arg1; /**< Arguement #1 */
- gchar *arg2; /**< Arguement #2 */
- gchar *arg3; /**< Arguement #3 */
+ gchar *uuid; /**< Device UUID */
+ gchar *addr; /**< Host address + Port */
+ gchar *sender; /**< Dbus Sender */
+ gchar *arg1; /**< Arguement #1 */
+ gchar *arg2; /**< Arguement #2 */
+ gchar *arg3; /**< Arguement #3 */
#ifdef SUPPORT_BASE64_ENCODING
unsigned char *data;
int data_len;
#define __MDGD_UTIL_H__
#ifdef __cplusplus
-extern "C"
-{
+extern "C" {
#endif
+#include <base64.h>
+#include <mdgd_log.h>
#include <octypes.h>
#include <pmtypes.h>
-#include <mdgd_log.h>
-#include <base64.h>
-const char* mdgd_ocf_error_to_string(int err);
-char* mdgd_get_readable_uuid(const OicUuid_t* uuid);
+const char *mdgd_ocf_error_to_string(int err);
+char *mdgd_get_readable_uuid(const OicUuid_t *uuid);
char *mdgd_addr2host(char *addr, int port, bool is_secure);
-int mdgd_uuid_to_str(const OicUuid_t* uuid, char** strUuid);
-int mdgd_str_to_uuid(const char *strUuid, OicUuid_t* uuid);
+int mdgd_uuid_to_str(const OicUuid_t *uuid, char **strUuid);
+int mdgd_str_to_uuid(const char *strUuid, OicUuid_t *uuid);
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_channel(mdgd_channel_t *channel);
GVariant *mdgd_create_variant_data(mdgd_data_t *data);
GVariant *mdgd_create_variant_device_list(char *group_name);
-GVariant *mdgd_create_variant_progress(char *file_path,
- long send_size, long total_size, int percent);
+GVariant *mdgd_create_variant_progress(char *file_path, long send_size, long total_size, int percent);
GVariant *mdgd_create_variant_dummy();
mdgd_device_t *mdgd_get_device_from_variant(GVariant *va);
int mdgd_util_get_msg_id();
-void mdgd_util_data_encode(const char *data, int data_len,
- char **encoded_data, int *encoded_len);
-
-void mdgd_util_data_decode(const char *data, int data_len,
- char **decoded_data, int *decoded_len);
-
+void mdgd_util_data_encode(const char *data, int data_len, char **encoded_data, int *encoded_len);
#ifdef __cplusplus
}
*
*/
-#include <mdgd_db.h>
#include <mdgd_context.h>
+#include <mdgd_db.h>
#include <mdgd_group.h>
static bool __is_table_existing(const char *table)
}
sql = sqlite3_mprintf("CREATE TABLE %s(id INTEGER PRIMARY KEY, group_name TEXT);",
- MDGD_DB_GROUP_TABLE);
+ MDGD_DB_GROUP_TABLE);
if (sql != NULL) {
sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
}
sql = sqlite3_mprintf("CREATE TABLE %s(id INTEGER PRIMARY KEY, group_name TEXT, device_id TEXT, model_name TEXT, device_name TEXT, platform_ver TEXT, vendor_id TEXT, profile TEXT, is_invited INTEGER, type INTEGER);",
- MDGD_DB_DEVICE_TABLE);
+ MDGD_DB_DEVICE_TABLE);
if (sql != NULL) {
sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
if (mdgd_ctx->db == NULL) {
sql_ret = sqlite3_open_v2(MDGD_DB_FILE, &(mdgd_ctx->db),
- SQLITE_OPEN_FULLMUTEX | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
+ SQLITE_OPEN_FULLMUTEX | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
if (sql_ret != SQLITE_OK) {
LOG_ERR("sqlite3_open_v2 failed, (%d)", sql_ret);
goto ERR;
}
sql = sqlite3_mprintf("INSERT INTO %s (group_name) values(%Q);",
- MDGD_DB_GROUP_TABLE,
- group_name);
+ MDGD_DB_GROUP_TABLE,
+ group_name);
if (sql != NULL) {
sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
}
sql = sqlite3_mprintf("INSERT INTO %s (group_name, device_id, model_name, device_name, platform_ver, vendor_id, profile, is_invited, type) values(%Q, %Q, %Q, %Q, %Q, %Q, %Q, %d, %d);",
- MDGD_DB_DEVICE_TABLE,
- group_name,
- device->device_id,
- device->model_name,
- device->device_name,
- device->platform_ver,
- device->vendor_id,
- device->profile,
- device->is_invited,
- device->type);
+ MDGD_DB_DEVICE_TABLE,
+ group_name,
+ device->device_id,
+ device->model_name,
+ device->device_name,
+ device->platform_ver,
+ device->vendor_id,
+ device->profile,
+ device->is_invited,
+ device->type);
if (sql != NULL) {
sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
}
sql = sqlite3_mprintf("DELETE FROM %s WHERE group_name=%Q",
- MDGD_DB_GROUP_TABLE,
- group_name);
+ MDGD_DB_GROUP_TABLE,
+ group_name);
if (sql != NULL) {
sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
}
sql = sqlite3_mprintf("DELETE FROM %s WHERE group_name=%Q and device_id=%Q",
- MDGD_DB_DEVICE_TABLE,
- group_name,
- device_id);
+ MDGD_DB_DEVICE_TABLE,
+ group_name,
+ device_id);
if (sql != NULL) {
sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
}
return ret;
-
}
bool mdgd_db_check_device_exist(char *device_id)
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
sql = sqlite3_mprintf("SELECT count(*) FROM %s WHERE device_id=%Q;",
- MDGD_DB_DEVICE_TABLE, device_id);
+ MDGD_DB_DEVICE_TABLE, device_id);
if (sql != NULL) {
sqlite3_stmt *stmt = NULL;
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);
+ MDGD_DB_DEVICE_TABLE, group_name, device_id);
if (sql != NULL) {
sqlite3_stmt *stmt = NULL;
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
sql = sqlite3_mprintf("SELECT count(*) FROM %s WHERE group_name=%Q;",
- MDGD_DB_GROUP_TABLE, group_name);
+ MDGD_DB_GROUP_TABLE, group_name);
if (sql != NULL) {
sqlite3_stmt *stmt = NULL;
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);
+ MDGD_DB_DEVICE_TABLE, group_name);
if (sql != NULL) {
sqlite3_stmt *stmt = NULL;
LOG_END();
}
-
int mdgd_db_group_print()
{
int ret, i = 0;
return 0;
}
-
#include <sys/types.h>
#include <mdgd_db.h>
-#include <mdgd_util.h>
#include <mdgd_gdbus.h>
#include <mdgd_group.h>
+#include <mdgd_util.h>
static Group *group_skeleton;
static Enabler *enabler_skeleton;
gboolean group_create(Group *group, GDBusMethodInvocation *invocation,
- gchar *group_name, gpointer user_data)
+ gchar *group_name, gpointer user_data)
{
gint result = MDGD_ERROR_NONE;
}
gboolean group_find(Group *group, GDBusMethodInvocation *invocation, gint timeout,
- gpointer user_data)
+ gpointer user_data)
{
gint result = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
}
gboolean group_delete(Group *group, GDBusMethodInvocation *invocation,
- gchar *group_name, gpointer user_data)
+ gchar *group_name, gpointer user_data)
{
gint result = MDGD_ERROR_NONE;
}
gboolean group_find_device(Group *group, GDBusMethodInvocation *invocation,
- gint timeout, gint is_invited, gpointer user_data)
+ gint timeout, gint is_invited, gpointer user_data)
{
int result = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
}
gboolean group_invite_device(Group *group, GDBusMethodInvocation *invocation, gchar *group_name,
- GVariant *va, gchar *pin, gpointer user_data)
+ GVariant *va, gchar *pin, gpointer user_data)
{
gint result = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
}
gboolean group_eject_device(Group *group, GDBusMethodInvocation *invocation, gchar *group_name,
- gchar *uuid, gpointer user_data)
+ gchar *uuid, gpointer user_data)
{
gint result = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
}
gboolean group_get_local_device(Group *group,
- GDBusMethodInvocation *invocation, gpointer user_data)
+ GDBusMethodInvocation *invocation, gpointer user_data)
{
GVariant *device_data;
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
}
gboolean group_get_local_channel_list(Group *group,
- GDBusMethodInvocation *invocation, gpointer user_data)
+ GDBusMethodInvocation *invocation, gpointer user_data)
{
GVariant *device_data;
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
}
gboolean group_foreach_device(Group *group, GDBusMethodInvocation *invocation,
- gchar *group_name, gpointer user_data)
+ gchar *group_name, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
GVariant *va;
}
gboolean group_regist_channel(Group *group, GDBusMethodInvocation *invocation,
- gchar *channel_id, gpointer user_data)
+ gchar *channel_id, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
}
gboolean group_unregist_channel(Group *group, GDBusMethodInvocation *invocation,
- gchar *channel_id, gpointer user_data)
+ gchar *channel_id, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
}
gboolean group_send_data(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gchar *channel_id, GVariant *params, gpointer user_data)
+ gchar *uuid, gchar *channel_id, GVariant *params, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
}
gboolean group_send_response(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gchar *channel_id, gint msg_id, GVariant *params, gpointer user_data)
+ gchar *uuid, gchar *channel_id, gint msg_id, GVariant *params, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
}
gboolean group_send_file(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gchar *file_path, gpointer user_data)
+ gchar *uuid, gchar *file_path, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
ret = mdgd_group_request(MDGD_REQ_SEND_FILE, (char *)sender, uuid,
- file_path, NULL, NULL, NULL);
+ file_path, NULL, NULL, NULL);
group_complete_send_file(group, invocation, ret);
return ret;
}
-gboolean group_request_create_group(Group *group, GDBusMethodInvocation
- *invocation, gchar *uuid, gchar *group_name, gpointer user_data)
+gboolean group_request_create_group(Group *group, GDBusMethodInvocation *invocation, gchar *uuid, gchar *group_name, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
ret = mdgd_group_request(MDGD_REQ_CREATE_GROUP, (char *)sender, uuid,
- group_name, NULL, NULL, NULL);
+ group_name, NULL, NULL, NULL);
group_complete_request_create_group(group, invocation, ret);
}
gboolean group_request_invite(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gchar *group_name, gchar *target_uuid, gchar *PIN, gpointer user_data)
+ gchar *uuid, gchar *group_name, gchar *target_uuid, gchar *PIN, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
ret = mdgd_group_request(MDGD_REQ_INVITE_DEVICE, (char *)sender, uuid,
- group_name, target_uuid, PIN, NULL);
+ group_name, target_uuid, PIN, NULL);
group_complete_request_invite(group, invocation, ret);
}
gboolean group_request_eject(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gchar *group_name, gchar *target_uuid, gpointer user_data)
+ gchar *uuid, gchar *group_name, gchar *target_uuid, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
ret = mdgd_group_request(MDGD_REQ_EJECT_DEVICE, (char *)sender, uuid,
- group_name, target_uuid, NULL, NULL);
+ group_name, target_uuid, NULL, NULL);
group_complete_request_eject(group, invocation, ret);
}
gboolean group_request_channel_list(Group *group, GDBusMethodInvocation *invocation,
- gchar *uuid, gpointer user_data)
+ gchar *uuid, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
const gchar *sender = g_dbus_method_invocation_get_sender(invocation);
LOG_BEGIN();
ret = mdgd_group_request(MDGD_REQ_CHANNEL_LIST, (char *)sender, uuid,
- NULL, NULL, NULL, NULL);
+ NULL, NULL, NULL, NULL);
group_complete_request_channel_list(group, invocation, ret);
}
gboolean group_set_preconfigured_pin(Group *group, GDBusMethodInvocation *invocation,
- gchar *preconfigured_pin, gpointer user_data)
+ gchar *preconfigured_pin, gpointer user_data)
{
int ret = MDGD_ERROR_NONE;
signal_variant = g_variant_ref_sink(g_variant_new("(ii@a{sv})", type, ret, data));
ret = g_dbus_connection_emit_signal(mdgd_ctx->connection,
- sender,
- MDGD_DBUS_GROUP_PATH,
- MDGD_DBUS_GROUP_INTERFACE,
- "Event",
- signal_variant,
- &error);
+ sender,
+ MDGD_DBUS_GROUP_PATH,
+ MDGD_DBUS_GROUP_INTERFACE,
+ "Event",
+ signal_variant,
+ &error);
if (ret == FALSE) {
LOG_DEBUG("g_dbus_connection_emit_signal is failed : %s", error->message);
// Register for method callbacks as signal callbacks
g_signal_connect(group_skeleton,
- "handle-create",
- G_CALLBACK(group_create),
- NULL);
+ "handle-create",
+ G_CALLBACK(group_create),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-find",
- G_CALLBACK(group_find),
- NULL);
+ "handle-find",
+ G_CALLBACK(group_find),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-delete",
- G_CALLBACK(group_delete),
- NULL);
+ "handle-delete",
+ G_CALLBACK(group_delete),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-find-device",
- G_CALLBACK(group_find_device),
- NULL);
+ "handle-find-device",
+ G_CALLBACK(group_find_device),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-invite-device",
- G_CALLBACK(group_invite_device),
- NULL);
+ "handle-invite-device",
+ G_CALLBACK(group_invite_device),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-eject-device",
- G_CALLBACK(group_eject_device),
- NULL);
+ "handle-eject-device",
+ G_CALLBACK(group_eject_device),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-regist-channel",
- G_CALLBACK(group_regist_channel),
- NULL);
+ "handle-regist-channel",
+ G_CALLBACK(group_regist_channel),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-unregist-channel",
- G_CALLBACK(group_unregist_channel),
- NULL);
+ "handle-unregist-channel",
+ G_CALLBACK(group_unregist_channel),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-send-data",
- G_CALLBACK(group_send_data),
- NULL);
+ "handle-send-data",
+ G_CALLBACK(group_send_data),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-send-response",
- G_CALLBACK(group_send_response),
- NULL);
+ "handle-send-response",
+ G_CALLBACK(group_send_response),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-send-file",
- G_CALLBACK(group_send_file),
- NULL);
+ "handle-send-file",
+ G_CALLBACK(group_send_file),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-get-local-device",
- G_CALLBACK(group_get_local_device),
- NULL);
+ "handle-get-local-device",
+ G_CALLBACK(group_get_local_device),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-get-local-channel-list",
- G_CALLBACK(group_get_local_channel_list),
- NULL);
+ "handle-get-local-channel-list",
+ G_CALLBACK(group_get_local_channel_list),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-foreach-device",
- G_CALLBACK(group_foreach_device),
- NULL);
+ "handle-foreach-device",
+ G_CALLBACK(group_foreach_device),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-request-create-group",
- G_CALLBACK(group_request_create_group),
- NULL);
+ "handle-request-create-group",
+ G_CALLBACK(group_request_create_group),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-request-invite",
- G_CALLBACK(group_request_invite),
- NULL);
+ "handle-request-invite",
+ G_CALLBACK(group_request_invite),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-request-eject",
- G_CALLBACK(group_request_eject),
- NULL);
+ "handle-request-eject",
+ G_CALLBACK(group_request_eject),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-request-channel-list",
- G_CALLBACK(group_request_channel_list),
- NULL);
+ "handle-request-channel-list",
+ G_CALLBACK(group_request_channel_list),
+ NULL);
g_signal_connect(group_skeleton,
- "handle-set-preconfigured-pin",
- G_CALLBACK(group_set_preconfigured_pin),
- NULL);
+ "handle-set-preconfigured-pin",
+ G_CALLBACK(group_set_preconfigured_pin),
+ NULL);
group = g_dbus_object_manager_server_new(MDGD_DBUS_GROUP_PATH);
// Export 'group' interface on mdg-manager DBUS
ret = g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(group_skeleton),
- connection, MDGD_DBUS_GROUP_PATH, &error);
+ connection, MDGD_DBUS_GROUP_PATH, &error);
if (ret == FALSE) {
LOG_DEBUG("Can not skeleton_export %s", error->message);
}
static void _app_conn_destroyed_cb(GDBusConnection *conn, const gchar *Name,
- const gchar *path, const gchar *interface, const gchar *sig,
- GVariant *param, gpointer user_data)
+ const gchar *path, const gchar *interface, const gchar *sig,
+ GVariant *param, gpointer user_data)
{
gchar *name = NULL;
gchar *old = NULL;
if (g_strcmp0(name, data->conn_name) == 0 && *new == '\0') {
LOG_DEBUG("App %s Destroyed: name %s id %d", data->conn_name, name,
- data->conn_id);
+ data->conn_id);
mdgd_ctx->ref_count -= 1;
}
static gboolean _register_mdgd_conn_destroy_signal(Enabler *enabler,
- gchar *name)
+ gchar *name)
{
mdgd_conn_destroy_data *data;
GDBusConnection *connection = NULL;
connection = g_dbus_interface_skeleton_get_connection(
- (GDBusInterfaceSkeleton *)enabler_skeleton);
+ (GDBusInterfaceSkeleton *)enabler_skeleton);
if (NULL == connection) {
LOG_ERR("Failed to get GDbus connection");
return FALSE;
data->connection = connection;
data->conn_id = g_dbus_connection_signal_subscribe(connection,
- DBUS_SERVICE_DBUS, DBUS_INTERFACE_DBUS,
- "NameOwnerChanged", NULL, name,
- G_DBUS_SIGNAL_FLAGS_NONE, _app_conn_destroyed_cb,
- data, NULL);
+ DBUS_SERVICE_DBUS, DBUS_INTERFACE_DBUS,
+ "NameOwnerChanged", NULL, name,
+ G_DBUS_SIGNAL_FLAGS_NONE, _app_conn_destroyed_cb,
+ data, NULL);
return TRUE;
}
gboolean enabler_add_ref(Enabler *enabler, GDBusMethodInvocation *invocation,
- gchar *name, gpointer user_data)
+ gchar *name, gpointer user_data)
{
LOG_DEBUG("Add Reference for %s", name);
// Register for method callbacks as signal callbacks
g_signal_connect(enabler_skeleton,
- "handle-add-ref",
- G_CALLBACK(enabler_add_ref),
- NULL);
+ "handle-add-ref",
+ G_CALLBACK(enabler_add_ref),
+ NULL);
enabler = g_dbus_object_manager_server_new(MDGD_DBUS_ENABLER_PATH);
// Export 'enabler' interface on mdg DBUS
ret = g_dbus_interface_skeleton_export(
- G_DBUS_INTERFACE_SKELETON(enabler_skeleton), connection,
- MDGD_DBUS_ENABLER_PATH, &error);
+ G_DBUS_INTERFACE_SKELETON(enabler_skeleton), connection,
+ MDGD_DBUS_ENABLER_PATH, &error);
if (ret == FALSE) {
LOG_DEBUG("Can not skeleton_export %s", error->message);
return ret;
}
-
static void on_bus_acquired(GDBusConnection *connection, const gchar *path,
- gpointer user_data)
+ gpointer user_data)
{
mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
mdgd_ctx->connection = connection;
}
static void on_name_acquired(GDBusConnection *connection, const gchar *name,
- gpointer user_data)
+ gpointer user_data)
{
LOG_DEBUG("on_name_acquired : %s", name);
}
static void on_name_lost(GDBusConnection *connnection, const gchar *name,
- gpointer user_data)
+ gpointer user_data)
{
LOG_DEBUG("on_name_lost : %s", name);
}
int mdgd_gdbus_init()
{
g_bus_own_name(G_BUS_TYPE_SYSTEM, MDGD_DBUS_SERVICE, G_BUS_NAME_OWNER_FLAGS_NONE,
- on_bus_acquired, on_name_acquired, on_name_lost, NULL, NULL);
+ on_bus_acquired, on_name_acquired, on_name_lost, NULL, NULL);
return 0;
}
*
*/
-#include <mdgd_group.h>
-#include <mdgd_db.h>
#include <mdgd_context.h>
+#include <mdgd_db.h>
#include <mdgd_gdbus.h>
+#include <mdgd_group.h>
#include <mdgd_iot.h>
-int mdgd_group_create(const char* name)
+int mdgd_group_create(const char *name)
{
int ret = MDGD_ERROR_NONE;
ret = mdgd_iot_find_devices(sender, timeout, is_invited);
if (ret != MDGD_ERROR_NONE) {
LOG_ERR("Failed to find device : %s",
- mdgd_log_get_error_string(ret));
+ mdgd_log_get_error_string(ret));
}
g_timeout_add_seconds(timeout + 1, __timeout_cb, cmd);
#define FULL_PERMISSION 31
int mdgd_group_invite_device(char *sender, char *group_name,
- mdgd_device_t *device, char *pin)
+ mdgd_device_t *device, char *pin)
{
int ret = MDGD_ERROR_NONE;
mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx, MDGD_ERROR_INVALID_PARAMETER);
ret = mdgd_iot_pair(group_name, pin, mdgd_ctx->device_uuid, device->device_id, "/comp/data",
- "core.comp.data", "oic.if.baseline", FULL_PERMISSION, device->device_id,
- mdgd_ctx->device_uuid, "/comp/data", "core.comp.data",
- "oic.if.baseline", FULL_PERMISSION);
+ "core.comp.data", "oic.if.baseline", FULL_PERMISSION, device->device_id,
+ mdgd_ctx->device_uuid, "/comp/data", "core.comp.data",
+ "oic.if.baseline", FULL_PERMISSION);
if (ret == MDGD_ERROR_NONE && mdgd_db_check_device_exist_in_group(group_name, device->device_id) == false) {
mdgd_db_device_insert(group_name, device);
if (channel_id == NULL) {
int removed_count;
removed_count = g_hash_table_foreach_remove(mdgd_ctx->channel,
- __foreach_hash_table, sender);
+ __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);
}
int mdgd_group_send_data(char *sender, char *uuid, char *channel_id,
- unsigned char *data, int len, int *msg_id)
+ unsigned char *data, int len, int *msg_id)
{
int ret;
}
int mdgd_group_send_response(char *sender, char *uuid, char *channel_id,
- int msg_id, unsigned char *data, int len)
+ int msg_id, unsigned char *data, int len)
{
int ret;
}
int mdgd_group_request(mdgd_request_type_e type, char *sender, char *uuid,
- char *arg1, char *arg2, char *arg3, void *user_data)
+ char *arg1, char *arg2, char *arg3, void *user_data)
{
int ret;
#include <tzplatform_config.h>
-#include <utlist.h>
#include <sys/utsname.h>
+#include <utlist.h>
#include <octypes.h>
#include <pmtypes.h>
#include <pmutility.h>
#include <securevirtualresourcetypes.h>
+#include <doxmresource.h>
#include <iotivity_config.h>
-#include <platform_features.h>
#include <ocprovisioningmanager.h>
-#include <doxmresource.h>
+#include <platform_features.h>
#include <system_info.h>
-#include <vconf.h>
#include <system_settings.h>
+#include <vconf.h>
-#include <mdgd_iot.h>
-#include <mdgd_group.h>
-#include <mdgd_gdbus.h>
#include <mdgd_db.h>
+#include <mdgd_gdbus.h>
+#include <mdgd_group.h>
+#include <mdgd_iot.h>
#include <mdgd_util.h>
-#include "OCProvisioningManager.hpp"
-#include "OCPlatform.h"
#include "OCApi.h"
+#include "OCPlatform.h"
+#include "OCProvisioningManager.hpp"
#include "credresource.h"
using namespace OC;
using namespace std;
-#define DISCOVERY_TIMEOUT 6 /**< 6 sec */
+#define DISCOVERY_TIMEOUT 6 /**< 6 sec */
#define CALLBACK_TIMEOUT_5S 5 * 1000 /**< 5sec = 5 * 1000 * 1ms */
-#define CALLBACK_MARGIN 10 * 1000 /**< 10sec */
-#define TIME_UNIT 10 /**< Sleep time unit */
+#define CALLBACK_MARGIN 10 * 1000 /**< 10sec */
+#define TIME_UNIT 10 /**< Sleep time unit */
bool g_doneCB;
return ret;
}
-static FILE* __client_open(const char* /*path*/, const char *mode)
+static FILE *__client_open(const char * /*path*/, const char *mode)
{
- char data_dir[MAX_FILE_PATH_LEN] = {0,};
+ char data_dir[MAX_FILE_PATH_LEN] = {
+ 0,
+ };
snprintf(data_dir, MAX_FILE_PATH_LEN, "%s/network/%s",
- "/opt/usr/data", SVR_DB_FILE_NAME);
+ "/opt/usr/data", SVR_DB_FILE_NAME);
- return fopen(data_dir, mode);
+ return fopen(data_dir, mode);
}
static int __get_platform_info(OCPlatformInfo *platform_info)
LOG_ERR("system_info_get_platform_string() Fail(%d)", ret);
snprintf(platform_id, sizeof(platform_id), "%s(%s)",
- device_name ? device_name : "", tizen_id ? tizen_id : "");
+ device_name ? device_name : "", tizen_id ? tizen_id : "");
free(device_name);
free(tizen_id);
/* Mandatory (oic.wk.p) */
ret = system_info_get_platform_string(SYSTEM_INFO_MANUF_NAME,
- &platform_info->manufacturerName);
+ &platform_info->manufacturerName);
if (SYSTEM_INFO_ERROR_NONE != ret) {
LOG_ERR("system_info_get_platform_string(manufacturer) Fail(%d)", ret);
free(platform_info->platformID);
}
ret = system_info_get_platform_string(SYSTEM_INFO_MODEL_NAME,
- &platform_info->modelNumber);
+ &platform_info->modelNumber);
if (SYSTEM_INFO_ERROR_NONE != ret)
LOG_ERR("system_info_get_platform_string(model_name) Fail(%d)", ret);
ret = system_info_get_platform_string(SYSTEM_INFO_PLATFORM_VERSION,
- &platform_info->platformVersion);
+ &platform_info->platformVersion);
if (SYSTEM_INFO_ERROR_NONE != ret)
LOG_ERR("system_info_get_platform_string(platform_version) Fail(%d)", ret);
ret = system_info_get_platform_string(SYSTEM_INFO_BUILD_STRING,
- &platform_info->firmwareVersion);
+ &platform_info->firmwareVersion);
if (SYSTEM_INFO_ERROR_NONE != ret)
LOG_ERR("system_info_get_platform_string(build_string) Fail(%d)", ret);
return ret;
}
-int mdgd_iot_find_devices(char* sender, int timeout, bool is_invited)
+int mdgd_iot_find_devices(char *sender, int timeout, bool is_invited)
{
int result = MDGD_ERROR_NONE;
DeviceList_t devList;
devList = g_mowned_list;
}
- for (unsigned int i = 0; i < devList.size(); i++ ) {
+ for (unsigned int i = 0; i < devList.size(); i++) {
char *uuid_str = NULL;
OCProvisionDev_t *selDev = devList[i]->getDevPtr();
UuidList_t subOwnerList;
devList[i]->getSubOwnerList(subOwnerList);
- for(unsigned int j = 0; j < subOwnerList.size(); j++) {
+ for (unsigned int j = 0; j < subOwnerList.size(); j++) {
char *readable_uuid = mdgd_get_readable_uuid(&subOwnerList[j]);
LOG_DEBUG("remote owner uuid is %s", readable_uuid);
return result;
}
-static OCProvisionDev_t* _get_dev_by_uuid(DeviceList_t &list, OicUuid_t *target)
+static OCProvisionDev_t *_get_dev_by_uuid(DeviceList_t &list, OicUuid_t *target)
{
- for (unsigned int i = 0; i < list.size(); i++ ) {
+ for (unsigned int i = 0; i < list.size(); i++) {
if (list[i]->getDeviceID().compare((const char *)target)) {
return list[i]->getDevPtr();
}
static int _get_devid_by_uuid(DeviceList_t &list, OicUuid_t *target)
{
char *t = mdgd_get_readable_uuid(target);
- for (unsigned int i = 0; i < list.size(); i++ ) {
+ for (unsigned int i = 0; i < list.size(); i++) {
if (0 == list[i]->getDeviceID().compare(t)) {
return i;
}
return -1;
}
-static OicUuid_t* _convert_uuid(gchar *device_id)
+static OicUuid_t *_convert_uuid(gchar *device_id)
{
OicUuid_t *uuid;
LOG_DEBUG("Multiple Ownership Transfer Result = %d", has_error);
for (unsigned int i = 0; result && i < result->size(); i++) {
LOG_DEBUG("[%d] %s = [%d][%s]",
- i,
- mdgd_get_readable_uuid(&result->at(i).deviceId),
- result->at(i).res,
- mdgd_ocf_error_to_string(result->at(i).res));
+ i,
+ mdgd_get_readable_uuid(&result->at(i).deviceId),
+ result->at(i).res,
+ mdgd_ocf_error_to_string(result->at(i).res));
}
g_doneCB = true;
}
-int mdgd_iot_pair(char *group_name, char *pin, 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_iot_pair(char *group_name, char *pin, 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 idx1 = -1;
int idx2 = -1;
OicUuid_t *uuid_3 = NULL;
OicUuid_t *uuid_4 = NULL;
- OicSecAcl_t* acl_1 = NULL;
- OicSecAcl_t* acl_2 = NULL;
+ OicSecAcl_t *acl_1 = NULL;
+ OicSecAcl_t *acl_2 = NULL;
OCProvisionDev_t *target_dev_1 = NULL;
OCProvisionDev_t *target_dev_2 = NULL;
PV_PAIR_END:
/* Restore MOT enabled devices */
if (src_dev)
- src_dev->next = next_dev ;
+ src_dev->next = next_dev;
/* Notify pair result */
if (uuid_1)
LOG_DEBUG("Remove Device Result = %d", has_error);
for (unsigned int i = 0; result && i < result->size(); i++) {
LOG_DEBUG("[%d] %s = [%d][%s]",
- i,
- mdgd_get_readable_uuid(&result->at(i).deviceId),
- result->at(i).res,
- mdgd_ocf_error_to_string(result->at(i).res));
+ i,
+ mdgd_get_readable_uuid(&result->at(i).deviceId),
+ result->at(i).res,
+ mdgd_ocf_error_to_string(result->at(i).res));
}
g_doneCB = true;
}
ret = OCSecure::removeDeviceWithUuid(CALLBACK_TIMEOUT_5S, str, _remove_cb);
if (OC_STACK_OK != ret) {
LOG_DEBUG("removeDeviceWithUuid API error = %d (%s)", ret,
- mdgd_log_get_iot_error_string(ret));
+ mdgd_log_get_iot_error_string(ret));
goto PV_UNPAIR_END;
} else {
ret = _wait_cb_ret(CALLBACK_TIMEOUT_5S);
if (OC_STACK_OK != ret) {
LOG_DEBUG("removeDeviceWithUuid Timeout = %d (%s)", ret,
- mdgd_log_get_iot_error_string(ret));
+ mdgd_log_get_iot_error_string(ret));
goto PV_UNPAIR_END;
}
}
ps.close = fclose;
ps.unlink = unlink;
- PlatformConfig cfg {
- OC::ServiceType::InProc,
- OC::ModeType::Both,
- (OCTransportAdapter)(OCTransportAdapter::OC_ADAPTER_IP),
- OC::QualityOfService::LowQos,
- &ps
- };
+ PlatformConfig cfg{
+ OC::ServiceType::InProc,
+ OC::ModeType::Both,
+ (OCTransportAdapter)(OCTransportAdapter::OC_ADAPTER_IP),
+ OC::QualityOfService::LowQos,
+ &ps};
OCPlatform::Configure(cfg);
ret = OCPlatform::registerPlatformInfo(platform_info);
__clean_platform_info(&platform_info);
- if (ret != OC_STACK_OK)
- {
+ if (ret != OC_STACK_OK) {
LOG_ERR("Platform Registration failed");
return MDGD_ERROR_NONE;
- }
+ }
OCDeviceInfo device_info = {0};
device_info.deviceName = g_strdup("UNKNOWN");
ret = OCPlatform::registerDeviceInfo(device_info);
g_free(device_info.deviceName);
- if (ret != OC_STACK_OK)
- {
+ if (ret != OC_STACK_OK) {
LOG_ERR("Device Registration failed");
return MDGD_ERROR_NONE;
- }
+ }
OicUuid_t uuid;
ret = GetDoxmDeviceID(&uuid);
- if (OC_STACK_OK != ret)
+ if (OC_STACK_OK != ret)
LOG_DEBUG("GetDoxmDevOwnerId failed = [%d][%s]", ret, get_error_message(ret));
ret = mdgd_uuid_to_str(&uuid, &device_id);
- if (OC_STACK_OK != ret)
+ if (OC_STACK_OK != ret)
LOG_DEBUG("mdgd_uuid_to_str failed = [%d][%s]", ret, get_error_message(ret));
LOG_DEBUG("device_id : %s", device_id);
/* Do Self-Ownership Transfer */
ret = OCSecure::configSelfOwnership();
- if (OC_STACK_OK != ret ) {
+ if (OC_STACK_OK != ret) {
LOG_ERR("OCConfigSelfOwnership() error = [%d][%s]", ret, get_error_message(ret));
}
- mdgd_iot_add_resource(MDGD_RESOURCE_TYPE_GROUP, ""); //For Group
+ mdgd_iot_add_resource(MDGD_RESOURCE_TYPE_GROUP, ""); //For Group
mdgd_iot_add_resource(MDGD_RESOURCE_TYPE_DEVICE, ""); //For Device Description
- mdgd_iot_add_resource(MDGD_RESOURCE_TYPE_DATA, ""); //For Secure Data Transfer
+ mdgd_iot_add_resource(MDGD_RESOURCE_TYPE_DATA, ""); //For Secure Data Transfer
- char data_dir[MAX_FILE_PATH_LEN] = {0,};
+ char data_dir[MAX_FILE_PATH_LEN] = {
+ 0,
+ };
snprintf(data_dir, MAX_FILE_PATH_LEN, "%s/network/%s",
- "/opt/usr/data", PRVN_DB_FILE_NAME);
+ "/opt/usr/data", PRVN_DB_FILE_NAME);
ret = OCInitPM(data_dir);
if (OC_STACK_OK != ret)
LOG_ERR("OCInitPM() error = [%d][%s]", ret, get_error_message(ret));
- OCProvisionDev_t* motdev_list = NULL;
+ OCProvisionDev_t *motdev_list = NULL;
OCDiscoverMultipleOwnerEnabledDevices(1, &motdev_list);
OCProvisionDev_t *iter = NULL;
device->device_id = device_id;
device->device_name = g_strdup(device_name);
device->model_name = g_strdup(model_name);
- device->platform_ver = g_strdup(platform_ver);
+ device->platform_ver = g_strdup(platform_ver);
device->profile = g_strdup(profile);
device->vendor_id = g_strdup("6FFF");
device->is_invited = true;
#include <tzplatform_config.h>
-#include <utlist.h>
#include <sys/utsname.h>
+#include <utlist.h>
#include <octypes.h>
#include <pmtypes.h>
#include <pmutility.h>
#include <securevirtualresourcetypes.h>
+#include <doxmresource.h>
#include <iotivity_config.h>
-#include <platform_features.h>
#include <ocprovisioningmanager.h>
-#include <doxmresource.h>
+#include <platform_features.h>
#include <system_info.h>
-#include <vconf.h>
#include <system_settings.h>
+#include <vconf.h>
-#include <mdgd_iot.h>
-#include <mdgd_group.h>
-#include <mdgd_gdbus.h>
-#include <mdgd_db.h>
#include <map>
+#include <mdgd_db.h>
+#include <mdgd_gdbus.h>
+#include <mdgd_group.h>
+#include <mdgd_iot.h>
-#include "OCProvisioningManager.hpp"
-#include "OCPlatform.h"
#include "OCApi.h"
+#include "OCPlatform.h"
+#include "OCProvisioningManager.hpp"
+#include <errno.h>
+#include <fcntl.h>
#include <stdio.h>
-#include <sys/types.h>
+#include <string.h>
#include <sys/socket.h>
-#include <unistd.h>
#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
using namespace OC;
using namespace std;
FILE *fd = NULL;
char buf[MAXBUF];
long total_bytes;
- char tempaddr[26] = {0,};
+ char tempaddr[26] = {
+ 0,
+ };
LOG_BEGIN();
else
sock = socket(AF_INET, SOCK_STREAM, 0);
- if(sock < 0) {
+ if (sock < 0) {
LOG_ERR("socket() error");
ret = MDGD_ERROR_OPERATION_FAILED;
goto SEND_THREAD_EXIT;
strtok(tempaddr, "%");
inet_pton(AF_INET6, tempaddr, &serveraddr_v6.sin6_addr);
- retval = connect(sock, (struct sockaddr*)&serveraddr_v6, sizeof(serveraddr_v6));
+ retval = connect(sock, (struct sockaddr *)&serveraddr_v6, sizeof(serveraddr_v6));
} else {
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(PORT);
strtok(tempaddr, ":");
inet_pton(AF_INET, tempaddr, &serveraddr.sin_addr.s_addr);
- retval = connect(sock, (struct sockaddr*)&serveraddr, sizeof(serveraddr));
+ retval = connect(sock, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
}
LOG_DEBUG("Connect to %s. Sending %s file...", tempaddr, cmd->arg1);
/* connect */
- if(retval < 0) {
+ if (retval < 0) {
LOG_ERR("connect() error : %s", strerror(errno));
ret = MDGD_ERROR_OPERATION_FAILED;
goto SEND_THREAD_EXIT;
}
-
-
fd = fopen(cmd->arg1, "rb");
- if(fd == NULL) {
+ if (fd == NULL) {
LOG_ERR("fopen() error : %s", strerror(errno));
ret = MDGD_ERROR_OPERATION_FAILED;
goto SEND_THREAD_EXIT;
total_bytes = ftell(fd);
rewind(fd);
- while(1) {
+ while (1) {
num_read = fread(buf, 1, MAXBUF, fd);
- if(num_read > 0) {
+ if (num_read > 0) {
prev_percent = cur_percent;
retval = write(sock, buf, num_read);
- if(retval == -1) {
+ if (retval == -1) {
LOG_ERR("write() error! : %s", strerror(errno));
ret = MDGD_ERROR_OPERATION_FAILED;
goto SEND_THREAD_EXIT;
}
num_total += num_read;
- cur_percent = (int)(((gdouble)num_total /(gdouble)total_bytes) * 100);
+ cur_percent = (int)(((gdouble)num_total / (gdouble)total_bytes) * 100);
if (prev_percent != cur_percent) {
LOG_DEBUG("The file is %d percent sended", cur_percent);
mdgd_gdbus_emit_event(cmd->sender, MDGD_EVENT_SEND_FILE_PROGRESS, MDGD_ERROR_NONE,
- mdgd_create_variant_progress(cmd->arg1, num_total, total_bytes, cur_percent));
+ mdgd_create_variant_progress(cmd->arg1, num_total, total_bytes, cur_percent));
}
- }
- else if(num_read == 0 && num_total == total_bytes) {
+ } else if (num_read == 0 && num_total == total_bytes) {
LOG_DEBUG("file trans complete : %d bytes\n", num_total);
break;
- }
- else {
+ } else {
LOG_ERR("file I/O error : %s", strerror(errno));
ret = MDGD_ERROR_OPERATION_FAILED;
goto SEND_THREAD_EXIT;
close(sock);
mdgd_gdbus_emit_event(cmd->sender, MDGD_EVENT_SEND_FILE_FINISH, ret,
- mdgd_create_variant_dummy());
+ mdgd_create_variant_dummy());
LOG_END();
return NULL;
}
-static void __get_group_information(const HeaderOptions& headerOptions,
- const OCRepresentation& rep, const int eCode, void *user_data)
+static void __get_group_information(const HeaderOptions &headerOptions,
+ const OCRepresentation &rep, const int eCode, void *user_data)
{
LOG_BEGIN();
try {
if (eCode == OC_STACK_OK || eCode == OC_STACK_RESOURCE_CREATED ||
- eCode == OC_STACK_RESOURCE_CHANGED) {
+ eCode == OC_STACK_RESOURCE_CHANGED) {
mdgd_check_null_ret("user_data", user_data);
mdgd_group_t *group = (mdgd_group_t *)user_data;
std::vector<std::string> group_list;
}
LOG_DEBUG("Device %s Number of groups %d", group->device_id,
- group_list.size());
+ group_list.size());
for (i = 0; i < group_list.size(); i++) {
group->group_name = g_strdup(group_list[i].c_str());
LOG_DEBUG("Group Found : %s, Type : %d", group->group_name,
- group->type);
+ group->type);
mdgd_group_notify_event(group->sender, MDGD_EVENT_GROUP_FOUND,
- MDGD_ERROR_NONE, (void *)group);
+ MDGD_ERROR_NONE, (void *)group);
g_free(group->group_name);
group->group_name = NULL;
}
} else {
LOG_ERR("__get_device_description Response error %d", eCode);
}
- } catch(std::exception& e) {
+ } catch (std::exception &e) {
LOG_ERR("Exception %s in on get", e.what());
}
mdgd_data_t *tmp_data_t = (mdgd_data_t *)l->data;
if (tmp_data_t->msg_id == send_data->msg_id) {
mdgd_group_notify_event(tmp_data_t->sender, MDGD_EVENT_SEND_DATA_FINISH,
- MDGD_ERROR_NETWORK_UNREACHABLE, tmp_data_t);
+ MDGD_ERROR_NETWORK_UNREACHABLE, tmp_data_t);
mdgd_ctx->send_data = g_slist_remove_link(mdgd_ctx->send_data, l);
break;
return false;
}
-static void __send_event_finish(const HeaderOptions&,
- const OCRepresentation& rep, const int eCode)
+static void __send_event_finish(const HeaderOptions &,
+ const OCRepresentation &rep, const int eCode)
{
LOG_DEBUG("Send Event Finished");
}
-static void __send_data_finish(const HeaderOptions&,
- const OCRepresentation& rep, const int eCode,
- void *user_data)
+static void __send_data_finish(const HeaderOptions &,
+ const OCRepresentation &rep, const int eCode,
+ void *user_data)
{
int ret = MDGD_ERROR_NONE;
std::string channel_id, data;
int msg_id;
- char* decoded_data;
+ char *decoded_data;
int decoded_len, data_len = 0;
bool time_out;
LOG_END();
}
-static void __request_finish(const HeaderOptions&,
- const OCRepresentation& rep, const int eCode,
- void *user_data)
+static void __request_finish(const HeaderOptions &,
+ const OCRepresentation &rep, const int eCode,
+ void *user_data)
{
int ret = MDGD_ERROR_NONE;
try {
if (eCode == OC_STACK_OK || eCode == OC_STACK_RESOURCE_CREATED ||
- eCode == OC_STACK_RESOURCE_CHANGED) {
+ eCode == OC_STACK_RESOURCE_CHANGED) {
if (cmd->type == MDGD_REQ_CHANNEL_LIST) {
std::map<std::string, AttributeValue> channel_list = rep.getValues();
std::map<std::string, AttributeValue>::iterator iter;
} else {
LOG_ERR("__get_device_description Response error %d", eCode);
}
- } catch(std::exception& e) {
+ } catch (std::exception &e) {
LOG_ERR("Exception %s in on get", e.what());
}
}
static bool _found_resource(std::shared_ptr<OCResource> resource,
- void *user_data)
+ void *user_data)
{
char *resource_type = NULL;
std::string resourceURI;
try {
if (resource) {
- for(auto &resourceTypes : resource->getResourceTypes()) {
+ for (auto &resourceTypes : resource->getResourceTypes()) {
if (resource_type == NULL)
resource_type = g_strdup(resourceTypes.c_str());
}
LOG_DEBUG("URI [%s], Host [%s], Device ID [%s], Resource [%s]",
- resource->uri().c_str(), resource->host().c_str(), resource->sid().c_str(), resource_type);
+ resource->uri().c_str(), resource->host().c_str(), resource->sid().c_str(), resource_type);
if (g_strcmp0(resource_type,
- mdgd_resource_get_type(MDGD_RESOURCE_TYPE_GROUP)) == 0) {
+ mdgd_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->sender = g_strdup(cmd->sender);
}
resource->get(QueryParamsMap(), std::bind(&__get_group_information,
- std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, group));
+ std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, group));
} else if (g_strcmp0(resource_type,
- mdgd_resource_get_type(MDGD_RESOURCE_TYPE_DEVICE)) == 0 &&
- g_strcmp0(cmd->uuid, resource->sid().c_str()) == 0) {
+ mdgd_resource_get_type(MDGD_RESOURCE_TYPE_DEVICE)) == 0 &&
+ g_strcmp0(cmd->uuid, resource->sid().c_str()) == 0) {
rep.setValue("CMD", cmd->type);
rep.setValue("DeviceID", std::string(mdgd_ctx->device_uuid));
rep.setValue("GroupName", std::string(cmd->arg1));
- resource->put(rep, QueryParamsMap(), std::bind(&__send_event_finish,
- std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
+ resource->put(rep, QueryParamsMap(), std::bind(&__send_event_finish, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
} else if (g_strcmp0(resource_type,
- mdgd_resource_get_type(MDGD_RESOURCE_TYPE_DATA)) == 0 &&
- g_strcmp0(cmd->uuid, resource->sid().c_str()) == 0) {
+ mdgd_resource_get_type(MDGD_RESOURCE_TYPE_DATA)) == 0 &&
+ g_strcmp0(cmd->uuid, resource->sid().c_str()) == 0) {
rep.setValue("CMD", cmd->type);
rep.setValue("DeviceID", std::string(mdgd_ctx->device_uuid));
mdgd_ctx->send_data = g_slist_prepend(mdgd_ctx->send_data, send_data);
mdgd_context_mutex_unlock();
- resource->post(rep, QueryParamsMap(), std::bind (&__send_data_finish,
- std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, send_data));
+ resource->post(rep, QueryParamsMap(), std::bind(&__send_data_finish, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, send_data));
} else {
switch (cmd->type) {
case MDGD_REQ_SEND_FILE:
return FALSE;
}
- resource->post(rep, QueryParamsMap(), std::bind (&__request_finish,
- std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, cmd));
+ resource->post(rep, QueryParamsMap(), std::bind(&__request_finish, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, cmd));
}
}
- }
- else {
+ } else {
LOG_ERR("Resource is invalid");
}
- }
- catch(std::exception& e)
- {
+ } catch (std::exception &e) {
LOG_ERR("Exception in foundResource: %s", e.what());
}
}
int mdgd_iot_discovery_resource(mdgd_resource_type_e resource_type,
- void *user_data)
+ void *user_data)
{
int ret;
std::ostringstream requestURI;
LOG_BEGIN();
try {
- requestURI << OC_RSRVD_WELL_KNOWN_URI << "?rt=" <<
- mdgd_resource_get_type(resource_type);
+ requestURI << OC_RSRVD_WELL_KNOWN_URI << "?rt=" << mdgd_resource_get_type(resource_type);
- auto found_cb = std::bind (&_found_resource, std::placeholders::_1, cmd);
+ auto found_cb = std::bind(&_found_resource, std::placeholders::_1, cmd);
ret = OCPlatform::findResource("", requestURI.str(), CT_ADAPTER_IP, found_cb);
return ret;
}
-void __get_device_description(const HeaderOptions& headerOptions,
- const OCRepresentation& rep, const int eCode, void *user_data)
+void __get_device_description(const HeaderOptions &headerOptions,
+ const OCRepresentation &rep, const int eCode, void *user_data)
{
mdgd_check_null_ret("user_data", user_data);
try {
if (eCode == OC_STACK_OK || eCode == OC_STACK_RESOURCE_CREATED ||
- eCode == OC_STACK_RESOURCE_CHANGED) {
+ eCode == OC_STACK_RESOURCE_CHANGED) {
mdgd_check_null_ret("user_data", user_data);
mdgd_command_t *cmd = (mdgd_command_t *)user_data;
mdgd_device_t *device = (mdgd_device_t *)cmd->user_data;
} else {
LOG_ERR("__get_device_description Response error %d", eCode);
}
- } catch(std::exception& e) {
+ } catch (std::exception &e) {
LOG_ERR("Exception %s in on get", e.what());
}
LOG_BEGIN();
- uri_path = std::string(mdgd_resource_get_uri_prefix(MDGD_RESOURCE_TYPE_DEVICE));
+ uri_path = std::string(mdgd_resource_get_uri_prefix(MDGD_RESOURCE_TYPE_DEVICE));
OCResource::Ptr device_resource = OCPlatform::constructResourceObject(std::string(host_addr),
- uri_path, (OCConnectivityType)conn_type, false, resource_types, ifaces);
+ uri_path, (OCConnectivityType)conn_type, false, resource_types, ifaces);
- ret = device_resource->get(QueryParamsMap(), std::bind (&__get_device_description, std::placeholders::_1,
- std::placeholders::_2, std::placeholders::_3, cmd));
+ ret = device_resource->get(QueryParamsMap(), std::bind(&__get_device_description, std::placeholders::_1,
+ std::placeholders::_2, std::placeholders::_3, cmd));
LOG_END();
#include <tzplatform_config.h>
-#include <utlist.h>
#include <sys/utsname.h>
+#include <utlist.h>
#include <octypes.h>
#include <pmtypes.h>
#include <pmutility.h>
#include <securevirtualresourcetypes.h>
+#include <doxmresource.h>
#include <iotivity_config.h>
-#include <platform_features.h>
#include <ocprovisioningmanager.h>
-#include <doxmresource.h>
+#include <platform_features.h>
#include <system_info.h>
-#include <vconf.h>
#include <system_settings.h>
+#include <vconf.h>
-#include <mdgd_iot.h>
-#include <mdgd_group.h>
-#include <mdgd_gdbus.h>
#include <mdgd_db.h>
+#include <mdgd_gdbus.h>
+#include <mdgd_group.h>
+#include <mdgd_iot.h>
-#include "OCProvisioningManager.hpp"
-#include "OCPlatform.h"
#include "OCApi.h"
+#include "OCPlatform.h"
+#include "OCProvisioningManager.hpp"
+#include <errno.h>
+#include <fcntl.h>
#include <stdio.h>
-#include <sys/types.h>
+#include <string.h>
#include <sys/socket.h>
-#include <unistd.h>
#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
using namespace OC;
using namespace std;
std::shared_ptr<OC::OCResourceResponse> pResponse;
} OCResourceResponse_t;
-
-map <string, OCResourceHandle> addedResList;
+map<string, OCResourceHandle> addedResList;
/* FILE Receive in thread */
static gpointer __file_receive_thread_func(gpointer user_data)
{
socklen_t client_len;
struct linger ling;
mdgd_receive_file_t *receive_file = (mdgd_receive_file_t *)user_data;
- struct timeval tv_timeo = { 3, 0 };
+ struct timeval tv_timeo = {3, 0};
if (receive_file == NULL) {
LOG_ERR("receive_file is NULL");
LOG_DEBUG("file path : %s", receive_file->file_path);
fd = open(receive_file->file_path, O_WRONLY | O_CREAT | O_EXCL, 0700);
- if(!fd || errno == EEXIST) {
+ if (!fd || errno == EEXIST) {
LOG_ERR("file open error : %s", strerror(errno));
goto RECEIVE_THREAD_EXIT;
}
else
server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
- if(server_sockfd == -1) {
+ if (server_sockfd == -1) {
LOG_ERR("socket error : %s", strerror(errno));
goto RECEIVE_THREAD_EXIT;
}
LOG_DEBUG("Accepted IP : %s, client socket : %d", client_ipaddr);
}
- if(client_sockfd == -1) {
+ if (client_sockfd == -1) {
LOG_ERR("socket error : %s", strerror(errno));
goto RECEIVE_THREAD_EXIT;
}
- while(1) {
- char buf[MAXBUF] = {0,};
+ while (1) {
+ char buf[MAXBUF] = {
+ 0,
+ };
file_read_len = read(client_sockfd, buf, MAXBUF);
write(fd, buf, file_read_len);
if (file_read_len == EOF || file_read_len == 0) {
}
int mdgd_iot_send_response(char *sender, char *uuid, char *channel_id,
- int msg_id, unsigned char *data, int data_len, bool timeout)
+ int msg_id, unsigned char *data, int data_len, bool timeout)
{
int ret = MDGD_ERROR_NO_DATA;
for (l = mdg_ctx->receive_data; l != NULL; l = l->next) {
mdgd_data_t *tmp_data_t = (mdgd_data_t *)l->data;
if ((tmp_data_t->msg_id == msg_id) &&
- g_strcmp0(tmp_data_t->sender, sender) == 0 &&
- g_strcmp0(tmp_data_t->device_id, uuid) == 0) {
+ g_strcmp0(tmp_data_t->sender, sender) == 0 &&
+ g_strcmp0(tmp_data_t->device_id, uuid) == 0) {
OCResourceResponse_t *response = (OCResourceResponse_t *)tmp_data_t->user_data;
std::shared_ptr<OC::OCResourceResponse> pResponse = response->pResponse;
LOG_BEGIN();
ret = mdgd_iot_send_response(receive_data->sender, receive_data->device_id, receive_data->channel_id,
- receive_data->msg_id, NULL, 0, true);
+ receive_data->msg_id, NULL, 0, true);
if (ret != MDGD_ERROR_NONE)
LOG_ERR("There is not message");
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) {
+ 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) {
+ mdgd_resource_get_uri_prefix(MDGD_RESOURCE_TYPE_DEVICE)) == 0) {
char *device_name = NULL;
char *model_name = NULL;
char *platform_ver = NULL;
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) {
+ mdgd_resource_get_uri_prefix(MDGD_RESOURCE_TYPE_GROUP)) == 0) {
int group_count;
char *groups[256];
mdgd_db_get_groups(groups, &group_count);
std::vector<std::string> group_list;
for (int i = 0; i < group_count; i++) {
- LOG_DEBUG("%d. group name : %s", i+1, groups[i]);
+ LOG_DEBUG("%d. group name : %s", i + 1, groups[i]);
group_list.push_back(groups[i]);
}
responseRep.setValue("GroupList", group_list);
} else {
std::string group_name, uuid;
- switch(cmd) {
- case MDGD_REQ_SEND_FILE:
- {
+ switch (cmd) {
+ case MDGD_REQ_SEND_FILE: {
std::string file_path, conn_type;
LOG_DEBUG("Receive File");
if (!requestRep.getValue("FilePath", file_path))
receive_file->conn_type = g_strdup(conn_type.c_str());
g_thread_try_new("file_receive_thread",
- __file_receive_thread_func, receive_file, NULL);
+ __file_receive_thread_func, receive_file, NULL);
break;
}
LOG_ERR("UUID not found");
LOG_DEBUG("group name : %s, UUID : %s", group_name.c_str(),
- uuid.c_str());
+ uuid.c_str());
/* find device, and invite this device. */
/*
uuid.c_str(), "12341234");
*/
break;
- case MDGD_REQ_EJECT_DEVICE:
- {
- char *group_name_str = strdup(group_name.c_str());
- char *uuid_str = strdup(uuid.c_str());
- LOG_DEBUG("Request eject device");
-
- if (!requestRep.getValue("GroupName", group_name))
- LOG_ERR("Group name not found");
- if (!requestRep.getValue("ID", uuid))
- LOG_ERR("UUID not found");
-
- LOG_DEBUG("group name : %s Self UUID : %s Target UUID : %s",
- group_name_str, mdgd_ctx->device_uuid, uuid_str);
-
- result = mdgd_group_eject_device((char *)"tmp",
- group_name_str, uuid_str);
- free(group_name_str);
- free(uuid_str);
- }
- break;
+ case MDGD_REQ_EJECT_DEVICE: {
+ char *group_name_str = strdup(group_name.c_str());
+ char *uuid_str = strdup(uuid.c_str());
+ LOG_DEBUG("Request eject device");
+
+ if (!requestRep.getValue("GroupName", group_name))
+ LOG_ERR("Group name not found");
+ if (!requestRep.getValue("ID", uuid))
+ LOG_ERR("UUID not found");
+
+ LOG_DEBUG("group name : %s Self UUID : %s Target UUID : %s",
+ group_name_str, mdgd_ctx->device_uuid, uuid_str);
+
+ result = mdgd_group_eject_device((char *)"tmp",
+ group_name_str, uuid_str);
+ free(group_name_str);
+ free(uuid_str);
+ } break;
case MDGD_REQ_CHANNEL_LIST:
LOG_DEBUG("Request channel list");
GHashTableIter iter;
LOG_DEBUG("Send response : %d", OC_EH_OK);
OCPlatform::sendResponse(pResponse);
}
- } catch (std::exception& e) {
+ } catch (std::exception &e) {
LOG_ERR("Exception occured %s", e.what());
}
} else if (requestType == "PUT") {
if (strcmp(resourceUri.c_str(),
- mdgd_resource_get_uri_prefix(MDGD_RESOURCE_TYPE_DEVICE)) == 0) {
+ mdgd_resource_get_uri_prefix(MDGD_RESOURCE_TYPE_DEVICE)) == 0) {
int cmd;
std::string requester_id, group_name;
group->group_name = g_strdup(group_name.c_str());
group->type = MDGD_GROUP_TYPE_REMOTE;
- switch(cmd) {
+ switch (cmd) {
case MDGD_REQ_EVENT_INVITED:
mdgd_group_notify_event(NULL, MDGD_EVENT_INVITED, MDGD_ERROR_NONE, (void *)group);
break;
LOG_BEGIN();
- uri_path = std::string(mdgd_resource_get_uri_prefix(resource_type)) +
- std::string(uri);
+ 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));
+ 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;
int mdgd_iot_delete_resource(mdgd_resource_type_e resource_type, const char *uri)
{
- std::string uri_path;
-
- LOG_BEGIN();
-
- uri_path = std::string(mdgd_resource_get_uri_prefix(resource_type)) +
- std::string(uri);
+ std::string uri_path;
- LOG_DEBUG("[Delete] resource uri is %s", uri_path.c_str());
+ LOG_BEGIN();
- auto search = addedResList.find(uri_path);
- if (search != addedResList.end()) {
- LOG_DEBUG("[Saurav] Found resource handle");
- try {
- OCPlatform::unregisterResource(search->second);
- addedResList.erase(uri_path);
- LOG_DEBUG("[Saurav] Number of elements in hash %d",
- addedResList.size());
- } catch (std::exception& e) {
- LOG_ERR("Exception occured in unregistering %s", e.what());
- }
- }
+ uri_path = std::string(mdgd_resource_get_uri_prefix(resource_type)) +
+ std::string(uri);
+
+ LOG_DEBUG("[Delete] resource uri is %s", uri_path.c_str());
+
+ auto search = addedResList.find(uri_path);
+ if (search != addedResList.end()) {
+ LOG_DEBUG("[Saurav] Found resource handle");
+ try {
+ OCPlatform::unregisterResource(search->second);
+ addedResList.erase(uri_path);
+ LOG_DEBUG("[Saurav] Number of elements in hash %d",
+ addedResList.size());
+ } catch (std::exception &e) {
+ LOG_ERR("Exception occured in unregistering %s", e.what());
+ }
+ }
- return MDGD_ERROR_NONE;
+ return MDGD_ERROR_NONE;
}
-
#include <mdgd_log.h>
#include <octypes.h>
-#define CASE_TO_STR(x) case x: return #x;
-const char* mdgd_log_get_iot_error_string(int result)
+#define CASE_TO_STR(x) \
+ case x: \
+ return #x;
+const char *mdgd_log_get_iot_error_string(int result)
{
switch (result) {
- CASE_TO_STR(OC_STACK_OK)
- CASE_TO_STR(OC_STACK_RESOURCE_CREATED)
- CASE_TO_STR(OC_STACK_RESOURCE_DELETED)
- CASE_TO_STR(OC_STACK_CONTINUE)
- CASE_TO_STR(OC_STACK_RESOURCE_CHANGED)
- CASE_TO_STR(OC_STACK_INVALID_URI)
- CASE_TO_STR(OC_STACK_INVALID_QUERY)
- CASE_TO_STR(OC_STACK_INVALID_IP)
- CASE_TO_STR(OC_STACK_INVALID_PORT)
- CASE_TO_STR(OC_STACK_INVALID_CALLBACK)
- CASE_TO_STR(OC_STACK_INVALID_METHOD)
- CASE_TO_STR(OC_STACK_INVALID_PARAM)
- CASE_TO_STR(OC_STACK_INVALID_OBSERVE_PARAM)
+ CASE_TO_STR(OC_STACK_OK)
+ CASE_TO_STR(OC_STACK_RESOURCE_CREATED)
+ CASE_TO_STR(OC_STACK_RESOURCE_DELETED)
+ CASE_TO_STR(OC_STACK_CONTINUE)
+ CASE_TO_STR(OC_STACK_RESOURCE_CHANGED)
+ CASE_TO_STR(OC_STACK_INVALID_URI)
+ CASE_TO_STR(OC_STACK_INVALID_QUERY)
+ CASE_TO_STR(OC_STACK_INVALID_IP)
+ CASE_TO_STR(OC_STACK_INVALID_PORT)
+ CASE_TO_STR(OC_STACK_INVALID_CALLBACK)
+ CASE_TO_STR(OC_STACK_INVALID_METHOD)
+ CASE_TO_STR(OC_STACK_INVALID_PARAM)
+ CASE_TO_STR(OC_STACK_INVALID_OBSERVE_PARAM)
- CASE_TO_STR(OC_STACK_NO_MEMORY)
- CASE_TO_STR(OC_STACK_COMM_ERROR)
- CASE_TO_STR(OC_STACK_TIMEOUT)
- CASE_TO_STR(OC_STACK_ADAPTER_NOT_ENABLED)
- CASE_TO_STR(OC_STACK_NOTIMPL)
- CASE_TO_STR(OC_STACK_RESOURCE_ERROR)
- CASE_TO_STR(OC_STACK_SLOW_RESOURCE)
- CASE_TO_STR(OC_STACK_DUPLICATE_REQUEST)
- CASE_TO_STR(OC_STACK_OBSERVER_NOT_FOUND)
- CASE_TO_STR(OC_STACK_VIRTUAL_DO_NOT_HANDLE)
- CASE_TO_STR(OC_STACK_INVALID_OPTION)
- CASE_TO_STR(OC_STACK_MALFORMED_RESPONSE)
- CASE_TO_STR(OC_STACK_PERSISTENT_BUFFER_REQUIRED)
+ CASE_TO_STR(OC_STACK_NO_MEMORY)
+ CASE_TO_STR(OC_STACK_COMM_ERROR)
+ CASE_TO_STR(OC_STACK_TIMEOUT)
+ CASE_TO_STR(OC_STACK_ADAPTER_NOT_ENABLED)
+ CASE_TO_STR(OC_STACK_NOTIMPL)
+ CASE_TO_STR(OC_STACK_RESOURCE_ERROR)
+ CASE_TO_STR(OC_STACK_SLOW_RESOURCE)
+ CASE_TO_STR(OC_STACK_DUPLICATE_REQUEST)
+ CASE_TO_STR(OC_STACK_OBSERVER_NOT_FOUND)
+ CASE_TO_STR(OC_STACK_VIRTUAL_DO_NOT_HANDLE)
+ CASE_TO_STR(OC_STACK_INVALID_OPTION)
+ CASE_TO_STR(OC_STACK_MALFORMED_RESPONSE)
+ CASE_TO_STR(OC_STACK_PERSISTENT_BUFFER_REQUIRED)
- CASE_TO_STR(OC_STACK_INVALID_REQUEST_HANDLE)
- CASE_TO_STR(OC_STACK_INVALID_DEVICE_INFO)
- CASE_TO_STR(OC_STACK_INVALID_JSON)
- CASE_TO_STR(OC_STACK_UNAUTHORIZED_REQ)
- CASE_TO_STR(OC_STACK_TOO_LARGE_REQ)
- CASE_TO_STR(OC_STACK_PDM_IS_NOT_INITIALIZED)
- CASE_TO_STR(OC_STACK_DUPLICATE_UUID)
- CASE_TO_STR(OC_STACK_INCONSISTENT_DB)
- CASE_TO_STR(OC_STACK_SVR_DB_NOT_EXIST)
- CASE_TO_STR(OC_STACK_AUTHENTICATION_FAILURE)
- CASE_TO_STR(OC_STACK_NOT_ALLOWED_OXM)
+ CASE_TO_STR(OC_STACK_INVALID_REQUEST_HANDLE)
+ CASE_TO_STR(OC_STACK_INVALID_DEVICE_INFO)
+ CASE_TO_STR(OC_STACK_INVALID_JSON)
+ CASE_TO_STR(OC_STACK_UNAUTHORIZED_REQ)
+ CASE_TO_STR(OC_STACK_TOO_LARGE_REQ)
+ CASE_TO_STR(OC_STACK_PDM_IS_NOT_INITIALIZED)
+ CASE_TO_STR(OC_STACK_DUPLICATE_UUID)
+ CASE_TO_STR(OC_STACK_INCONSISTENT_DB)
+ CASE_TO_STR(OC_STACK_SVR_DB_NOT_EXIST)
+ CASE_TO_STR(OC_STACK_AUTHENTICATION_FAILURE)
+ CASE_TO_STR(OC_STACK_NOT_ALLOWED_OXM)
#ifdef WITH_PRESENCE
- CASE_TO_STR(OC_STACK_PRESENCE_STOPPED)
- CASE_TO_STR(OC_STACK_PRESENCE_TIMEOUT)
- CASE_TO_STR(OC_STACK_PRESENCE_DO_NOT_HANDLE)
+ CASE_TO_STR(OC_STACK_PRESENCE_STOPPED)
+ CASE_TO_STR(OC_STACK_PRESENCE_TIMEOUT)
+ CASE_TO_STR(OC_STACK_PRESENCE_DO_NOT_HANDLE)
#endif
- CASE_TO_STR(OC_STACK_USER_DENIED_REQ)
- CASE_TO_STR(OC_STACK_NOT_ACCEPTABLE)
- CASE_TO_STR(OC_STACK_METHOD_NOT_ALLOWED)
- CASE_TO_STR(OC_STACK_FORBIDDEN_REQ)
- CASE_TO_STR(OC_STACK_TOO_MANY_REQUESTS)
- CASE_TO_STR(OC_STACK_INTERNAL_SERVER_ERROR)
- CASE_TO_STR(OC_STACK_NOT_IMPLEMENTED)
- CASE_TO_STR(OC_STACK_BAD_GATEWAY)
- CASE_TO_STR(OC_STACK_SERVICE_UNAVAILABLE)
- CASE_TO_STR(OC_STACK_GATEWAY_TIMEOUT)
- CASE_TO_STR(OC_STACK_PROXY_NOT_SUPPORTED)
- CASE_TO_STR(OC_STACK_ERROR)
- default :
+ CASE_TO_STR(OC_STACK_USER_DENIED_REQ)
+ CASE_TO_STR(OC_STACK_NOT_ACCEPTABLE)
+ CASE_TO_STR(OC_STACK_METHOD_NOT_ALLOWED)
+ CASE_TO_STR(OC_STACK_FORBIDDEN_REQ)
+ CASE_TO_STR(OC_STACK_TOO_MANY_REQUESTS)
+ CASE_TO_STR(OC_STACK_INTERNAL_SERVER_ERROR)
+ CASE_TO_STR(OC_STACK_NOT_IMPLEMENTED)
+ CASE_TO_STR(OC_STACK_BAD_GATEWAY)
+ CASE_TO_STR(OC_STACK_SERVICE_UNAVAILABLE)
+ CASE_TO_STR(OC_STACK_GATEWAY_TIMEOUT)
+ CASE_TO_STR(OC_STACK_PROXY_NOT_SUPPORTED)
+ CASE_TO_STR(OC_STACK_ERROR)
+ default:
return "Unknown Error";
}
}
*/
#include <mdgd_context.h>
+#include <mdgd_db.h>
+#include <mdgd_gdbus.h>
#include <mdgd_group.h>
#include <mdgd_resource.h>
-#include <mdgd_gdbus.h>
-#include <mdgd_db.h>
int main(int argc, char *argv[])
{
* limitations under the License.
*
*/
-#include <time.h>
#include <mdgd_db.h>
#include <mdgd_util.h>
+#include <time.h>
-#define CASE_TO_STR(x) case x: return #x;
-const char* mdgd_ocf_error_to_string(int err)
+#define CASE_TO_STR(x) \
+ case x: \
+ return #x;
+const char *mdgd_ocf_error_to_string(int err)
{
switch (err) {
- /* CHECK: List all enum values here */
- CASE_TO_STR(OC_STACK_OK)
- CASE_TO_STR(OC_STACK_RESOURCE_CREATED)
- CASE_TO_STR(OC_STACK_RESOURCE_DELETED)
- CASE_TO_STR(OC_STACK_CONTINUE)
- CASE_TO_STR(OC_STACK_RESOURCE_CHANGED)
- CASE_TO_STR(OC_STACK_INVALID_URI)
- CASE_TO_STR(OC_STACK_INVALID_QUERY)
- CASE_TO_STR(OC_STACK_INVALID_IP)
- CASE_TO_STR(OC_STACK_INVALID_PORT)
- CASE_TO_STR(OC_STACK_INVALID_CALLBACK)
- CASE_TO_STR(OC_STACK_INVALID_METHOD)
- CASE_TO_STR(OC_STACK_INVALID_PARAM)
- CASE_TO_STR(OC_STACK_INVALID_OBSERVE_PARAM)
-
- CASE_TO_STR(OC_STACK_NO_MEMORY)
- CASE_TO_STR(OC_STACK_COMM_ERROR)
- CASE_TO_STR(OC_STACK_TIMEOUT)
- CASE_TO_STR(OC_STACK_ADAPTER_NOT_ENABLED)
- CASE_TO_STR(OC_STACK_NOTIMPL)
- CASE_TO_STR(OC_STACK_RESOURCE_ERROR)
- CASE_TO_STR(OC_STACK_SLOW_RESOURCE)
- CASE_TO_STR(OC_STACK_DUPLICATE_REQUEST)
- CASE_TO_STR(OC_STACK_OBSERVER_NOT_FOUND)
- CASE_TO_STR(OC_STACK_VIRTUAL_DO_NOT_HANDLE)
- CASE_TO_STR(OC_STACK_INVALID_OPTION)
- CASE_TO_STR(OC_STACK_MALFORMED_RESPONSE)
- CASE_TO_STR(OC_STACK_PERSISTENT_BUFFER_REQUIRED)
-
- CASE_TO_STR(OC_STACK_INVALID_REQUEST_HANDLE)
- CASE_TO_STR(OC_STACK_INVALID_DEVICE_INFO)
- CASE_TO_STR(OC_STACK_INVALID_JSON)
- CASE_TO_STR(OC_STACK_UNAUTHORIZED_REQ)
- CASE_TO_STR(OC_STACK_TOO_LARGE_REQ)
- CASE_TO_STR(OC_STACK_PDM_IS_NOT_INITIALIZED)
- CASE_TO_STR(OC_STACK_DUPLICATE_UUID)
- CASE_TO_STR(OC_STACK_INCONSISTENT_DB)
- CASE_TO_STR(OC_STACK_SVR_DB_NOT_EXIST)
- CASE_TO_STR(OC_STACK_AUTHENTICATION_FAILURE)
- CASE_TO_STR(OC_STACK_NOT_ALLOWED_OXM)
+ /* CHECK: List all enum values here */
+ CASE_TO_STR(OC_STACK_OK)
+ CASE_TO_STR(OC_STACK_RESOURCE_CREATED)
+ CASE_TO_STR(OC_STACK_RESOURCE_DELETED)
+ CASE_TO_STR(OC_STACK_CONTINUE)
+ CASE_TO_STR(OC_STACK_RESOURCE_CHANGED)
+ CASE_TO_STR(OC_STACK_INVALID_URI)
+ CASE_TO_STR(OC_STACK_INVALID_QUERY)
+ CASE_TO_STR(OC_STACK_INVALID_IP)
+ CASE_TO_STR(OC_STACK_INVALID_PORT)
+ CASE_TO_STR(OC_STACK_INVALID_CALLBACK)
+ CASE_TO_STR(OC_STACK_INVALID_METHOD)
+ CASE_TO_STR(OC_STACK_INVALID_PARAM)
+ CASE_TO_STR(OC_STACK_INVALID_OBSERVE_PARAM)
+
+ CASE_TO_STR(OC_STACK_NO_MEMORY)
+ CASE_TO_STR(OC_STACK_COMM_ERROR)
+ CASE_TO_STR(OC_STACK_TIMEOUT)
+ CASE_TO_STR(OC_STACK_ADAPTER_NOT_ENABLED)
+ CASE_TO_STR(OC_STACK_NOTIMPL)
+ CASE_TO_STR(OC_STACK_RESOURCE_ERROR)
+ CASE_TO_STR(OC_STACK_SLOW_RESOURCE)
+ CASE_TO_STR(OC_STACK_DUPLICATE_REQUEST)
+ CASE_TO_STR(OC_STACK_OBSERVER_NOT_FOUND)
+ CASE_TO_STR(OC_STACK_VIRTUAL_DO_NOT_HANDLE)
+ CASE_TO_STR(OC_STACK_INVALID_OPTION)
+ CASE_TO_STR(OC_STACK_MALFORMED_RESPONSE)
+ CASE_TO_STR(OC_STACK_PERSISTENT_BUFFER_REQUIRED)
+
+ CASE_TO_STR(OC_STACK_INVALID_REQUEST_HANDLE)
+ CASE_TO_STR(OC_STACK_INVALID_DEVICE_INFO)
+ CASE_TO_STR(OC_STACK_INVALID_JSON)
+ CASE_TO_STR(OC_STACK_UNAUTHORIZED_REQ)
+ CASE_TO_STR(OC_STACK_TOO_LARGE_REQ)
+ CASE_TO_STR(OC_STACK_PDM_IS_NOT_INITIALIZED)
+ CASE_TO_STR(OC_STACK_DUPLICATE_UUID)
+ CASE_TO_STR(OC_STACK_INCONSISTENT_DB)
+ CASE_TO_STR(OC_STACK_SVR_DB_NOT_EXIST)
+ CASE_TO_STR(OC_STACK_AUTHENTICATION_FAILURE)
+ CASE_TO_STR(OC_STACK_NOT_ALLOWED_OXM)
#ifdef WITH_PRESENCE
- CASE_TO_STR(OC_STACK_PRESENCE_STOPPED)
- CASE_TO_STR(OC_STACK_PRESENCE_TIMEOUT)
- CASE_TO_STR(OC_STACK_PRESENCE_DO_NOT_HANDLE)
+ CASE_TO_STR(OC_STACK_PRESENCE_STOPPED)
+ CASE_TO_STR(OC_STACK_PRESENCE_TIMEOUT)
+ CASE_TO_STR(OC_STACK_PRESENCE_DO_NOT_HANDLE)
#endif
- CASE_TO_STR(OC_STACK_USER_DENIED_REQ)
- CASE_TO_STR(OC_STACK_NOT_ACCEPTABLE)
- CASE_TO_STR(OC_STACK_METHOD_NOT_ALLOWED)
- CASE_TO_STR(OC_STACK_FORBIDDEN_REQ)
- CASE_TO_STR(OC_STACK_TOO_MANY_REQUESTS)
- CASE_TO_STR(OC_STACK_INTERNAL_SERVER_ERROR)
- CASE_TO_STR(OC_STACK_NOT_IMPLEMENTED)
- CASE_TO_STR(OC_STACK_BAD_GATEWAY)
- CASE_TO_STR(OC_STACK_SERVICE_UNAVAILABLE)
- CASE_TO_STR(OC_STACK_GATEWAY_TIMEOUT)
- CASE_TO_STR(OC_STACK_PROXY_NOT_SUPPORTED)
- CASE_TO_STR(OC_STACK_ERROR)
- default :
+ CASE_TO_STR(OC_STACK_USER_DENIED_REQ)
+ CASE_TO_STR(OC_STACK_NOT_ACCEPTABLE)
+ CASE_TO_STR(OC_STACK_METHOD_NOT_ALLOWED)
+ CASE_TO_STR(OC_STACK_FORBIDDEN_REQ)
+ CASE_TO_STR(OC_STACK_TOO_MANY_REQUESTS)
+ CASE_TO_STR(OC_STACK_INTERNAL_SERVER_ERROR)
+ CASE_TO_STR(OC_STACK_NOT_IMPLEMENTED)
+ CASE_TO_STR(OC_STACK_BAD_GATEWAY)
+ CASE_TO_STR(OC_STACK_SERVICE_UNAVAILABLE)
+ CASE_TO_STR(OC_STACK_GATEWAY_TIMEOUT)
+ CASE_TO_STR(OC_STACK_PROXY_NOT_SUPPORTED)
+ CASE_TO_STR(OC_STACK_ERROR)
+ default:
return "Unknown Error";
}
}
char g_uuid_str[256] = {0};
-char* mdgd_get_readable_uuid(const OicUuid_t* uuid)
+char *mdgd_get_readable_uuid(const OicUuid_t *uuid)
{
memset(g_uuid_str, 0, sizeof(g_uuid_str));
snprintf(g_uuid_str, sizeof(g_uuid_str),
- "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
- (*uuid).id[0], (*uuid).id[1], (*uuid).id[2], (*uuid).id[3],
- (*uuid).id[4], (*uuid).id[5], (*uuid).id[6], (*uuid).id[7],
- (*uuid).id[8], (*uuid).id[9], (*uuid).id[10], (*uuid).id[11],
- (*uuid).id[12], (*uuid).id[13], (*uuid).id[14], (*uuid).id[15]);
+ "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+ (*uuid).id[0], (*uuid).id[1], (*uuid).id[2], (*uuid).id[3],
+ (*uuid).id[4], (*uuid).id[5], (*uuid).id[6], (*uuid).id[7],
+ (*uuid).id[8], (*uuid).id[9], (*uuid).id[10], (*uuid).id[11],
+ (*uuid).id[12], (*uuid).id[13], (*uuid).id[14], (*uuid).id[15]);
return g_uuid_str;
}
if (is_secure != true) {
if (strchr(ip, ':')) /* IPv6 Adress */
return g_strdup_printf("coap://[%s%s%s]:%d", ip, "%25",
- percent + 1, port);
+ 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);
+ 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)
+int mdgd_uuid_to_str(const OicUuid_t *uuid, char **strUuid)
{
if (NULL == uuid || NULL == strUuid || NULL != *strUuid) {
LOG_ERR("ConvertUuidToStr : 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));
+ 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) {
+ 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", '-');
return OC_STACK_NO_MEMORY;
}
-int mdgd_str_to_uuid(const char* strUuid, OicUuid_t* uuid)
+int mdgd_str_to_uuid(const char *strUuid, OicUuid_t *uuid)
{
- if(NULL == strUuid || NULL == uuid) {
- LOG_ERR("ConvertStrToUuid : Invalid param");
- return OC_STACK_INVALID_PARAM;
+ if (NULL == strUuid || NULL == uuid) {
+ LOG_ERR("ConvertStrToUuid : Invalid param");
+ return OC_STACK_INVALID_PARAM;
}
size_t urnIdx = 0;
char convertedUuid[UUID_LENGTH * 2] = {0};
strUuidLen = strlen(strUuid);
- if(0 == strUuidLen) {
- LOG_DEBUG("The empty string detected, The UUID will be converted to "\
- "\"00000000-0000-0000-0000-000000000000\"");
- } else if(UUID_LENGTH * 2 + 4 == strUuidLen) {
- for(uuidIdx=0, urnIdx=0; uuidIdx < UUID_LENGTH ; uuidIdx++, urnIdx+=2) {
- if(*(strUuid + urnIdx) == '-') {
- urnIdx++;
- }
- sscanf(strUuid + urnIdx, "%2hhx", &convertedUuid[uuidIdx]);
- }
+ if (0 == strUuidLen) {
+ LOG_DEBUG("The empty string detected, The UUID will be converted to "
+ "\"00000000-0000-0000-0000-000000000000\"");
+ } else if (UUID_LENGTH * 2 + 4 == strUuidLen) {
+ for (uuidIdx = 0, urnIdx = 0; uuidIdx < UUID_LENGTH; uuidIdx++, urnIdx += 2) {
+ if (*(strUuid + urnIdx) == '-') {
+ urnIdx++;
+ }
+ sscanf(strUuid + urnIdx, "%2hhx", &convertedUuid[uuidIdx]);
+ }
} else {
- LOG_ERR("Invalid string uuid format, Please set the uuid as correct format");
- LOG_ERR("e.g) \"72616E64-5069-6E44-6576-557569643030\" (4-2-2-2-6)");
- LOG_ERR("e.g) \"\"");
+ LOG_ERR("Invalid string uuid format, Please set the uuid as correct format");
+ LOG_ERR("e.g) \"72616E64-5069-6E44-6576-557569643030\" (4-2-2-2-6)");
+ LOG_ERR("e.g) \"\"");
- return OC_STACK_INVALID_PARAM;
+ return OC_STACK_INVALID_PARAM;
}
memcpy(uuid->id, convertedUuid, UUID_LENGTH);
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_new_string(group->device_id));
g_variant_builder_add(builder, "{sv}", "GroupName",
- g_variant_new_string(group->group_name));
+ g_variant_new_string(group->group_name));
g_variant_builder_add(builder, "{sv}", "Type",
- g_variant_new_int32(group->type));
+ g_variant_new_int32(group->type));
va = g_variant_builder_end(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_new_string(device->device_id));
g_variant_builder_add(builder, "{sv}", "ModelName",
- g_variant_new_string(device->model_name));
+ g_variant_new_string(device->model_name));
g_variant_builder_add(builder, "{sv}", "DeviceName",
- g_variant_new_string(device->device_name));
+ g_variant_new_string(device->device_name));
g_variant_builder_add(builder, "{sv}", "PlatformVer",
- g_variant_new_string(device->platform_ver));
+ g_variant_new_string(device->platform_ver));
g_variant_builder_add(builder, "{sv}", "VendorID",
- g_variant_new_string(device->vendor_id));
+ g_variant_new_string(device->vendor_id));
g_variant_builder_add(builder, "{sv}", "Profile",
- g_variant_new_string(device->profile));
+ g_variant_new_string(device->profile));
g_variant_builder_add(builder, "{sv}", "IsInvited",
- g_variant_new_int32(device->is_invited));
+ g_variant_new_int32(device->is_invited));
g_variant_builder_add(builder, "{sv}", "Type",
- g_variant_new_int32(device->type));
+ g_variant_new_int32(device->type));
va = g_variant_builder_end(builder);
builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add(builder, "{sv}", "DeviceID",
- g_variant_new_string(receive_file->device_id));
+ g_variant_new_string(receive_file->device_id));
g_variant_builder_add(builder, "{sv}", "FilePath",
- g_variant_new_string(receive_file->file_path));
+ g_variant_new_string(receive_file->file_path));
va = g_variant_builder_end(builder);
builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add(builder, "{sv}", "DeviceID",
- g_variant_new_string(channel->device_id));
+ g_variant_new_string(channel->device_id));
g_variant_builder_add(builder, "{sv}", "ChannelID",
- g_variant_new_string(channel->channel_id));
+ g_variant_new_string(channel->channel_id));
va = g_variant_builder_end(builder);
GVariantBuilder *builder;
GVariant *params = NULL;
-
builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add(builder, "{sv}", "DeviceID",
- g_variant_new_string(data->device_id));
+ g_variant_new_string(data->device_id));
g_variant_builder_add(builder, "{sv}", "ChannelID",
- g_variant_new_string(data->channel_id));
+ g_variant_new_string(data->channel_id));
g_variant_builder_add(builder, "{sv}", "MsgID",
- g_variant_new_int32(data->msg_id));
+ g_variant_new_int32(data->msg_id));
if (data->data_len > 0) {
GVariantBuilder *bytearray_builder = NULL;
params = g_variant_new("a(y)", bytearray_builder);
g_variant_builder_add(builder, "{sv}", "Data",
- g_variant_new_variant(params));
+ g_variant_new_variant(params));
g_variant_builder_add(builder, "{sv}", "DataLen",
- g_variant_new_int32(data->data_len));
+ g_variant_new_int32(data->data_len));
g_variant_builder_unref(bytearray_builder);
}
}
GVariant *mdgd_create_variant_progress(char *file_path,
- long send_size, long total_size, int percent)
+ long send_size, long total_size, int percent)
{
GVariant *va;
builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add(builder, "{sv}", "FilePath",
- g_variant_new_string(file_path));
+ g_variant_new_string(file_path));
g_variant_builder_add(builder, "{sv}", "SendSize",
- g_variant_new_int64(send_size));
+ g_variant_new_int64(send_size));
g_variant_builder_add(builder, "{sv}", "TotalSize",
- g_variant_new_int64(total_size));
+ g_variant_new_int64(total_size));
g_variant_builder_add(builder, "{sv}", "Percent",
- g_variant_new_int32(percent));
+ g_variant_new_int32(percent));
va = g_variant_builder_end(builder);
/* Get all device in group */
mdgd_db_get_devices_in_group(group_name, devices, &device_count);
- for (int i = 0; i < device_count; i++)
- {
+ for (int i = 0; i < device_count; i++) {
mdgd_device_t *device = devices[i];
g_variant_builder_open(builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add(builder, "{sv}", "DeviceID",
- g_variant_new_string(device->device_id));
+ g_variant_new_string(device->device_id));
g_variant_builder_add(builder, "{sv}", "ModelName",
- g_variant_new_string(device->model_name));
+ g_variant_new_string(device->model_name));
g_variant_builder_add(builder, "{sv}", "DeviceName",
- g_variant_new_string(device->device_name));
+ g_variant_new_string(device->device_name));
g_variant_builder_add(builder, "{sv}", "PlatformVer",
- g_variant_new_string(device->platform_ver));
+ g_variant_new_string(device->platform_ver));
g_variant_builder_add(builder, "{sv}", "VendorID",
- g_variant_new_string(device->vendor_id));
+ g_variant_new_string(device->vendor_id));
g_variant_builder_add(builder, "{sv}", "Profile",
- g_variant_new_string(device->profile));
+ g_variant_new_string(device->profile));
g_variant_builder_add(builder, "{sv}", "IsInvited",
- g_variant_new_int32(device->is_invited));
+ g_variant_new_int32(device->is_invited));
g_variant_builder_add(builder, "{sv}", "Type",
- g_variant_new_int32(device->type));
+ g_variant_new_int32(device->type));
g_variant_builder_close(builder);
}
mdgd_device_t *device = calloc(1, sizeof(mdgd_device_t));
if (NULL == device) {
- /* LCOV_EXCL_START */
- LOG_ERR("Memory allocation failed");
- return NULL;
- /* LCOV_EXCL_STOP */
+ /* LCOV_EXCL_START */
+ LOG_ERR("Memory allocation failed");
+ return NULL;
+ /* LCOV_EXCL_STOP */
}
g_variant_get(va, "a{sv}", &iter);
}
void mdgd_util_data_encode(const char *data, int data_len,
- char **encoded_data, int *encoded_len)
+ char **encoded_data, int *encoded_len)
{
#ifdef SUPPORT_BASE64_ENCODING
size_t out_size;
}
if (B64_OK != b64Encode(
- (const uint8_t*)data,
- (const size_t)data_len,
- out,
- (const size_t)out_size,
- (uint32_t *)&encoded_len)) {
+ (const uint8_t *)data,
+ (const size_t)data_len,
+ out,
+ (const size_t)out_size,
+ (uint32_t *)&encoded_len)) {
LOG_ERR("Base64 encoding failed.");
g_free(out);
return;
}
void mdgd_util_data_decode(const char *data, int data_len,
- char **decoded_data, int *decoded_len)
+ char **decoded_data, int *decoded_len)
{
#ifdef SUPPORT_BASE64_ENCODING
size_t out_size;
}
if (B64_OK != b64Decode((const char *)data,
- (const size_t)data_len,
- (uint8_t *)out,
- (const size_t)out_size,
- (uint32_t *)&decoded_len)) {
+ (const size_t)data_len,
+ (uint8_t *)out,
+ (const size_t)out_size,
+ (uint32_t *)&decoded_len)) {
LOG_ERR("Base64 decoding failed.");
g_free(out);
return;
LOG_DEBUG("Successfully decoded %s", *decoded_data);
}
-
-
projects / platform / core / connectivity / mdg-manager.git / commitdiff