From ade4624f4838ab164cfde4a0c2ada13f325122d0 Mon Sep 17 00:00:00 2001 From: "saerome.kim" Date: Wed, 1 Aug 2018 14:44:44 +0900 Subject: [PATCH 01/16] Fixed typo mdg-test app. is using the previous name, So we change the name of mdg-test app. Change-Id: I0b30cc2994b2e9965d8fb08e05757354db019890 Signed-off-by: saerome.kim --- test/main.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) mode change 100755 => 100644 test/main.c diff --git a/test/main.c b/test/main.c old mode 100755 new mode 100644 index b522dcd..477af92 --- a/test/main.c +++ b/test/main.c @@ -99,7 +99,7 @@ static int __init_func(MManager *mm, struct menu_data *menu) } static struct menu_data menu_main[] = { - { "1", "Comp-Manager", menu_mdg_manager, NULL, NULL }, + { "1", "Mdg-Manager", menu_mdg_manager, NULL, NULL }, { NULL, NULL, }, }; @@ -137,7 +137,7 @@ int main(int arg, char **argv) mainloop = g_main_loop_new(NULL, FALSE); msg(""); - msg("* Companion-Manager Test application "); + msg("* Mdg-Manager Test application "); msg("* Build On: %s %s", __DATE__, __TIME__); if (__create_init_menu(init_menu) == FALSE) -- 2.7.4 From 7c64f0dd1b66c2d44652f3ce3e6d279a0315b9b3 Mon Sep 17 00:00:00 2001 From: Jihoon Jung Date: Wed, 8 Aug 2018 19:08:08 +0900 Subject: [PATCH 02/16] Add send response API Signed-off-by: Jihoon Jung Change-Id: I619577c74ea68871f075b9fbe34a966d470d89f6 --- include/mdg.h | 22 ++++++++++-------- include/mdg_internal.h | 4 ++-- src/mdg.c | 60 +++++++++++++++++++++++++++++++++++++++++++++----- src/mdg_dbus.c | 17 ++++++++++---- src/mdg_gdbus.xml | 8 +++++++ src/mdg_private.h | 5 ++++- src/mdg_util.c | 20 ++++++++++------- src/mdg_util.h | 4 ++-- test/mdg-manager.c | 42 ++++++++++++++++++++++++++--------- 9 files changed, 141 insertions(+), 41 deletions(-) diff --git a/include/mdg.h b/include/mdg.h index f92b7fc..205bbfe 100755 --- a/include/mdg.h +++ b/include/mdg.h @@ -738,7 +738,8 @@ typedef void (*mdg_device_find_finish_cb)(int result, void *user_data); * * @see mdg_device_send_data() */ -typedef void (*mdg_device_send_data_finish_cb)(int result, void *user_data); +typedef void (*mdg_device_send_data_finish_cb)(int result, mdg_device_h device, + char *channel_id, int msg_id, unsigned char *data, int len, void *user_data); /** * @brief Gets my local device handle. @@ -759,8 +760,7 @@ typedef void (*mdg_device_send_data_finish_cb)(int result, void *user_data); * @see mdg_device_info_get_my_uuid() * */ -int mdg_device_get_local_device(mdg_h handle, - mdg_device_h *device); +int mdg_device_get_local_device(mdg_h handle, mdg_device_h *device); /** * @brief Finds candidate devices to include my groups in the network. @@ -786,12 +786,16 @@ int mdg_device_find(mdg_h handle, int timeout, bool is_invited, mdg_device_found_cb found_cb, mdg_device_find_finish_cb finish_cb, void *user_data); -typedef void (*mdg_channel_cb)(int result, char *device_id, char *channel_id, - unsigned char *data, int data_length, void *user_data); +typedef void (*mdg_receive_data_cb)(int result, char *device_id, char *channel_id, + int msg_id, unsigned char *data, int len, void *user_data); /* Server Side */ int mdg_device_regist_channel(mdg_h handle, char *channel_id, - mdg_channel_cb channel_cb, void *user_data); + mdg_receive_data_cb receive_data_cb, void *user_data); + +/* In 5 seconds */ +int mdg_device_send_response(mdg_h handle, char *device_id, char *channel_id, + int msg_id, unsigned char *data, int len); int mdg_device_unregist_channel(mdg_h handle, char *channel_id); @@ -823,9 +827,9 @@ int mdg_device_unregist_channel(mdg_h handle, char *channel_id); * @see mdg_request_result_callback() * */ -int mdg_device_send_data(mdg_h handle, mdg_device_h device, char *channel_id, - unsigned char *data, int len, - mdg_device_send_data_finish_cb finish_cb, void *user_data); +int mdg_device_send_data(mdg_h handle, + mdg_device_h device, char *channel_id, unsigned char *data, int len, + mdg_device_send_data_finish_cb finish_cb, void *user_data, int *msg_id); /** * @} diff --git a/include/mdg_internal.h b/include/mdg_internal.h index 52fd474..9eee306 100755 --- a/include/mdg_internal.h +++ b/include/mdg_internal.h @@ -24,8 +24,8 @@ extern "C" { #endif /* File transfer for Client Side */ -typedef void (*mdg_send_file_progress_cb)(const char *file_path, long send_size, - long total_size, int percent, void *user_data); +typedef void (*mdg_send_file_progress_cb)(const char *file_path, long long send_size, + long long total_size, int percent, void *user_data); typedef void (*mdg_send_file_finish_cb)(int result, mdg_device_h device, void *user_data); int mdg_device_send_file(mdg_h handle, mdg_device_h device, char *file_path, diff --git a/src/mdg.c b/src/mdg.c index b84f955..62844c7 100755 --- a/src/mdg.c +++ b/src/mdg.c @@ -173,7 +173,7 @@ EXPORT_API int mdg_device_find(mdg_h handle, int timeout, bool is_invited, /** * Companion Manager CAPI */ -int __add_channel_cb(mdg_manager_s *handle, char *channel_id, mdg_channel_cb channel_cb, void *user_data) +int __add_channel_cb(mdg_manager_s *handle, char *channel_id, mdg_receive_data_cb channel_cb, void *user_data) { channel_cb_s *channel_s; @@ -201,7 +201,7 @@ int __add_channel_cb(mdg_manager_s *handle, char *channel_id, mdg_channel_cb cha } EXPORT_API int mdg_device_regist_channel(mdg_h handle, char *channel_id, - mdg_channel_cb channel_cb, void *user_data) + mdg_receive_data_cb receive_data_cb, void *user_data) { int ret = MDG_ERROR_NONE; GError *error = NULL; @@ -222,13 +222,59 @@ EXPORT_API int mdg_device_regist_channel(mdg_h handle, char *channel_id, } if (ret == MDG_ERROR_NONE) - ret = __add_channel_cb(handle, channel_id, channel_cb, user_data); + ret = __add_channel_cb(handle, channel_id, receive_data_cb, user_data); _END(); return ret; } +EXPORT_API int mdg_device_send_response(mdg_h handle, char *device_id, char *channel_id, + int msg_id, unsigned char *data, int len) +{ + int ret = MDG_ERROR_NONE; + unsigned char *buf = NULL; + GVariantBuilder *bytearray_builder = NULL; + int i; + GVariant *params = NULL; + GError *error = NULL; + + CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + + mdg_manager_s *_handle = handle; + mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + CHECK_HANDLE_IS_VALID(handle); + + buf = g_try_malloc0(len + 1); + if (NULL == buf) { + /* LCOV_EXCL_START */ + _ERR("g_malloc0 is failed"); + return MDG_ERROR_OUT_OF_MEMORY; + /* LCOV_EXCL_STOP */ + } + memcpy(buf, data, len); + + bytearray_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); + for (i = 0; i < len; i++) + g_variant_builder_add(bytearray_builder, "y", buf[i]); + + params = g_variant_new("(iay)", len, bytearray_builder); + g_variant_builder_unref(bytearray_builder); + + group_call_send_response_sync(_handle->group_proxy, device_id, channel_id, msg_id, + params, &ret, NULL, &error); + if (error) { + _ERR("Failed DBus call [%s]", error->message); + g_error_free(error); + ret = MDG_ERROR_IO_ERROR; + } + + g_free(buf); + buf = NULL; + + return ret; +} + EXPORT_API int mdg_device_unregist_channel(mdg_h handle, char *channel_id) { int ret = MDG_ERROR_NONE; @@ -273,7 +319,7 @@ EXPORT_API int mdg_device_unregist_channel(mdg_h handle, char *channel_id) EXPORT_API int mdg_device_send_data(mdg_h handle, mdg_device_h device, char *channel_id, unsigned char *data, int len, - mdg_device_send_data_finish_cb finish_cb, void *user_data) + mdg_device_send_data_finish_cb finish_cb, void *user_data, int *msg_id) { int ret = MDG_ERROR_NONE; unsigned char *buf = NULL; @@ -307,11 +353,15 @@ EXPORT_API int mdg_device_send_data(mdg_h handle, params = g_variant_new("(iay)", len, bytearray_builder); g_variant_builder_unref(bytearray_builder); + mdg_device_h cloned_device = NULL; + mdg_device_info_clone(&cloned_device, device); + _handle->send_data_finish_cb.finish_cb = finish_cb; _handle->send_data_finish_cb.user_data = user_data; + _handle->send_data_finish_cb.device = cloned_device; group_call_send_data_sync(_handle->group_proxy, dev->device_id, - channel_id, params, &ret, NULL, &error); + channel_id, params, &ret, msg_id, NULL, &error); if (error) { _ERR("Failed DBus call [%s]", error->message); g_error_free(error); diff --git a/src/mdg_dbus.c b/src/mdg_dbus.c index 8e50fc1..c12d0b5 100755 --- a/src/mdg_dbus.c +++ b/src/mdg_dbus.c @@ -114,8 +114,16 @@ static void __event_cb(Group *object, } case MDG_EVENT_SEND_DATA_FINISH: { + char *device_id; + char *channel_id; + int msg_id; + unsigned char *data = NULL; + int data_len = 0; + + mdg_get_data_from_variant(va, &device_id, &channel_id, &msg_id, &data, &data_len); + mdg_device_s *device = (mdg_device_s *)(handle->send_data_finish_cb.device); if (handle->send_data_finish_cb.finish_cb) { - handle->send_data_finish_cb.finish_cb(ret, + handle->send_data_finish_cb.finish_cb(ret, device, channel_id, msg_id, data, data_len, handle->send_data_finish_cb.user_data); } else { _ERR("The callback not exists"); @@ -140,10 +148,11 @@ static void __event_cb(Group *object, { char *device_id; char *channel_id; + int msg_id; unsigned char *data; int data_len; - mdg_get_data_from_variant(va, &device_id, &channel_id, &data, &data_len); + mdg_get_data_from_variant(va, &device_id, &channel_id, &msg_id, &data, &data_len); channel_cb_s *channel = NULL; @@ -155,14 +164,14 @@ static void __event_cb(Group *object, } if (channel != NULL) - channel->cb(0, device_id, channel_id, data, data_len, channel->user_data); + channel->cb(0, device_id, channel_id, msg_id, data, data_len, channel->user_data); break; } case MDG_EVENT_SEND_FILE_PROGRESS: { if (handle->send_file_cb.progress_cb) { int percent = 0; - long send_size, total_size; + long long send_size, total_size; char *file_path; mdg_get_progress_from_variant(va, &file_path, &send_size, &total_size, &percent); handle->send_file_cb.progress_cb(file_path, send_size, total_size, percent, diff --git a/src/mdg_gdbus.xml b/src/mdg_gdbus.xml index bcb0828..0f72d56 100755 --- a/src/mdg_gdbus.xml +++ b/src/mdg_gdbus.xml @@ -62,6 +62,14 @@ + + + + + + + + diff --git a/src/mdg_private.h b/src/mdg_private.h index 8e8e245..532637f 100755 --- a/src/mdg_private.h +++ b/src/mdg_private.h @@ -115,6 +115,7 @@ typedef struct _device_eject_finish_cb_t { */ typedef struct _send_data_finish_cb_t { mdg_device_send_data_finish_cb finish_cb; /**< User callback to be called */ + mdg_device_h device; void *user_data; /**< User data pointer */ } send_data_finish_cb_t; @@ -203,7 +204,7 @@ typedef struct _mdg_device_s { typedef struct _channel_cb_s { char *channel_id; - mdg_channel_cb cb; + mdg_receive_data_cb cb; void *user_data; } channel_cb_s; @@ -221,6 +222,8 @@ typedef enum { MDG_EVENT_RECEIVE_FILE = 10, MDG_EVENT_SEND_FILE_PROGRESS, MDG_EVENT_SEND_FILE_FINISH, + MDG_EVENT_INVITED, + MDG_EVENT_EJECTED, } mdg_event_type_e; #endif /* __TIZEN_NETWORK_COMMON_MDG_PRIVATE_H__ */ diff --git a/src/mdg_util.c b/src/mdg_util.c index 501d6c0..7f10160 100755 --- a/src/mdg_util.c +++ b/src/mdg_util.c @@ -130,7 +130,7 @@ void mdg_get_channel_from_variant(GVariant *va, char **device_id, char **channel } void mdg_get_data_from_variant(GVariant *va, char **device_id, char **channel_id, - unsigned char **data, int *data_len) + int *msg_id, unsigned char **data, int *data_len) { GVariantIter *iter = NULL; const gchar *key; @@ -145,24 +145,28 @@ void mdg_get_data_from_variant(GVariant *va, char **device_id, char **channel_id *device_id = (char *)g_variant_get_string(key_value, NULL); else if (g_strcmp0(key, "ChannelID") == 0) *channel_id = (char *)g_variant_get_string(key_value, NULL); + else if (g_strcmp0(key, "MsgID") == 0) + *msg_id = g_variant_get_int32(key_value); else if (g_strcmp0(key, "Data") == 0) data_va = g_variant_get_variant(key_value); - else if (g_strcmp0(key, "DataLength") == 0) + else if (g_strcmp0(key, "DataLen") == 0) *data_len = g_variant_get_int32(key_value); } - int i = 0; - *data = (unsigned char *)g_try_malloc0(*data_len + 1); + if (*data_len > 0) { + int i = 0; + *data = (unsigned char *)g_try_malloc0(*data_len + 1); - g_variant_get(data_va, "a(y)", &data_iter); - while (g_variant_iter_loop(data_iter, "(y)", &byte_data)) - (*data)[i++] = byte_data; + g_variant_get(data_va, "a(y)", &data_iter); + while (g_variant_iter_loop(data_iter, "(y)", &byte_data)) + (*data)[i++] = byte_data; + } g_variant_iter_free(iter); } void mdg_get_progress_from_variant(GVariant *va, char **file_path, - long *send_size, long *total_size, int *percent) + long long *send_size, long long *total_size, int *percent) { GVariantIter *iter = NULL; const gchar *key; diff --git a/src/mdg_util.h b/src/mdg_util.h index ac64c8e..bfead55 100755 --- a/src/mdg_util.h +++ b/src/mdg_util.h @@ -30,10 +30,10 @@ mdg_device_s *mdg_get_device_from_variant(GVariant *va); mdg_group_s *mdg_get_group_from_variant(GVariant *va); void mdg_get_channel_from_variant(GVariant *va, char **device_id, char **channel_id); void mdg_get_data_from_variant(GVariant *va, char **device_id, char **channel_id, - unsigned char **data, int *data_len); + int *msg_id, unsigned char **data, int *data_len); void mdg_get_receive_file_from_variant(GVariant *va, char **device_id, char **file_path); void mdg_get_progress_from_variant(GVariant *va, char **file_path, - long *send_size, long *total_size, int *percent); + long long *send_size, long long *total_size, int *percent); #ifdef __cplusplus } diff --git a/test/mdg-manager.c b/test/mdg-manager.c index d6d40cb..f98df4a 100755 --- a/test/mdg-manager.c +++ b/test/mdg-manager.c @@ -765,9 +765,26 @@ static int run_group_create(MManager *mm, struct menu_data *menu) return RET_SUCCESS; } -void _send_data_finish_cb(int result, void *user_data) +void _send_data_finish2_cb(int result, mdg_device_h device, char *channel_id, int msg_id, + unsigned char *data, int len, void *user_data) { - msgb("\rFind Send Data Finished = %d", result); + msgb("\rmsg id = %d, data = %s, len = %d", msg_id, data, len); + msgb("\rSend Data once more Finished = %d", result); +} + +void _send_data_finish_cb(int result, mdg_device_h device, char *channel_id, int msg_id, + unsigned char *data, int len, void *user_data) +{ + int msg_id2; + + msgb("\rmsg id = %d, channel ID data = %s, len = %d", msg_id, data, len); + msgb("\rSend Data Finished = %d", result); + + msgb("\rSend Data Once more"); + mdg_device_send_data(handle, device, channel_id, (unsigned char *)"Welcome", + 7, _send_data_finish2_cb, NULL, &msg_id2); + + msgp("The message ID is %d", msg_id2); } static int __send_data(int devidx, int chaidx) @@ -804,11 +821,14 @@ static int __send_data(int devidx, int chaidx) address = NULL; } + int msg_id; ret = mdg_device_send_data(handle, device, channel->channel_id, (unsigned char *)message, - strlen(message), _send_data_finish_cb, NULL); + strlen(message), _send_data_finish_cb, NULL, &msg_id); if (MDG_ERROR_NONE != ret) msgr("Failed to Send Data: [ID] %s [IP] %s", deviceid, address); + msgp("The message ID is %d", msg_id); + return ret; } @@ -840,10 +860,10 @@ static int run_send_data(MManager *mm, struct menu_data *menu) return __send_data(devidx, chaidx); } -void __send_file_progress_cb(const char *file_path, long send_size, - long total_size, int percent, void *user_data) +void __send_file_progress_cb(const char *file_path, long long send_size, + long long total_size, int percent, void *user_data) { - msgp("%s %d%% [%ld/%ld]", file_path, percent, send_size, total_size); + msgp("%s %d%% [%lld/%lld]", file_path, percent, send_size, total_size); } void __send_file_finish_cb(int result, mdg_device_h device, void *user_data) { @@ -1186,12 +1206,14 @@ static int run_request_channel_list(MManager *mm, struct menu_data *menu) return RET_SUCCESS; } -void __channel_cb(int result, char *device_id, char *channel_id, +void __channel_cb(int result, char *device_id, char *channel_id, int msg_id, unsigned char *arg, int len, void *user_data) { - msg("[%s] channel callback is called by [%s]'s send message", channel_id, device_id); - msg("arg : %s, len : %d", arg, len); - msg("result is %d", result); + msgb("[%s] channel callback is called by [%s]'s send message", channel_id, device_id); + msgb("The msg_id is %d, arg : %s, len : %d", msg_id, arg, len); + msgb("result is %d", result); + + mdg_device_send_response(handle, device_id, channel_id, msg_id, (unsigned char *)"Ya, Hi", 6); } static int run_regist_channel(MManager *mm, struct menu_data *menu) -- 2.7.4 From c37d94c8f71afc6c73c67c812d52f17e3e98a2d5 Mon Sep 17 00:00:00 2001 From: Jihoon Jung Date: Thu, 9 Aug 2018 17:33:20 +0900 Subject: [PATCH 03/16] Add invited / ejected cb api Change-Id: Ic01335aea4b08a3aca4056d170810082e2f46196 Signed-off-by: Jihoon Jung --- include/mdg.h | 13 ++++++++++++ src/mdg.c | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/mdg_dbus.c | 27 ++++++++++++++++++++++++ src/mdg_private.h | 20 +++++++++++++----- test/mdg-manager.c | 25 ++++++++++++++++++++++- 5 files changed, 139 insertions(+), 6 deletions(-) diff --git a/include/mdg.h b/include/mdg.h index 205bbfe..5f43b12 100755 --- a/include/mdg.h +++ b/include/mdg.h @@ -72,6 +72,11 @@ typedef enum { MDG_ERROR_NOT_PROPER_DEVICE = TIZEN_ERROR_MDG | 0x09, /**< Not proper device */ } mdg_error_e; +typedef enum { + MDG_EVENT_INVITED = 0, + MDG_EVENT_EJECTED, +} mdg_event_type_e; + /** * @addtogroup CAPI_NETWORK_MDG_DEVICE_MODULE * @{ @@ -392,6 +397,14 @@ int mdg_group_invite_device(mdg_h handle, mdg_group_h group, mdg_device_h device, char *PIN, mdg_group_invite_device_finish_cb callback, void *user_data); +typedef void (*mdg_invited_event_cb)(mdg_group_h group, void *user_data); +int mdg_set_invited_event_cb(mdg_h handle, mdg_invited_event_cb event_cb, void *user_data); +int mdg_unset_invited_event_cb(mdg_h handle); + +typedef void (*mdg_ejected_event_cb)(mdg_group_h group, void *user_data); +int mdg_set_ejected_event_cb(mdg_h handle, mdg_ejected_event_cb event_cb, void *user_data); +int mdg_unset_ejected_event_cb(mdg_h handle); + /** * @brief Requests to expel the device from the group which local device owns. * @details This function is used to kick away a remote devices in my local group. diff --git a/src/mdg.c b/src/mdg.c index 62844c7..d2e83d0 100755 --- a/src/mdg.c +++ b/src/mdg.c @@ -1021,3 +1021,63 @@ EXPORT_API int mdg_request_result_callback(mdg_h handle, return ret; } +EXPORT_API int mdg_set_invited_event_cb(mdg_h handle, mdg_invited_event_cb invited_event_cb, void *user_data) +{ + int ret = MDG_ERROR_NONE; + + CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + + mdg_manager_s *_handle = handle; + mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + + _handle->invited_event_cb.invited_event_cb = invited_event_cb; + _handle->invited_event_cb.user_data = user_data; + + return ret; +} + +EXPORT_API int mdg_unset_invited_event_cb(mdg_h handle) +{ + int ret = MDG_ERROR_NONE; + + CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + + mdg_manager_s *_handle = handle; + mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + + _handle->invited_event_cb.invited_event_cb = NULL; + _handle->invited_event_cb.user_data = NULL; + + return ret; +} + +EXPORT_API int mdg_set_ejected_event_cb(mdg_h handle, mdg_ejected_event_cb ejected_event_cb, void *user_data) +{ + int ret = MDG_ERROR_NONE; + + CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + + mdg_manager_s *_handle = handle; + mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + + _handle->ejected_event_cb.ejected_event_cb = ejected_event_cb; + _handle->ejected_event_cb.user_data = user_data; + + return ret; +} + +EXPORT_API int mdg_unset_ejected_event_cb(mdg_h handle) +{ + int ret = MDG_ERROR_NONE; + + CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + + mdg_manager_s *_handle = handle; + mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + + _handle->ejected_event_cb.ejected_event_cb = NULL; + _handle->ejected_event_cb.user_data = NULL; + + return ret; +} + diff --git a/src/mdg_dbus.c b/src/mdg_dbus.c index c12d0b5..556018f 100755 --- a/src/mdg_dbus.c +++ b/src/mdg_dbus.c @@ -202,6 +202,33 @@ static void __event_cb(Group *object, } else { _ERR("The callback not exists"); } + break; + } + case MDG_EVENT_INVITED: + { + mdg_group_s *group = NULL; + + group = mdg_get_group_from_variant(va); + + if (handle->invited_event_cb.invited_event_cb) { + handle->invited_event_cb.invited_event_cb(group, handle->invited_event_cb.user_data); + } else { + _ERR("The callback not exists"); + } + break; + } + case MDG_EVENT_EJECTED: + { + mdg_group_s *group = NULL; + + group = mdg_get_group_from_variant(va); + + if (handle->ejected_event_cb.ejected_event_cb) { + handle->ejected_event_cb.ejected_event_cb(group, handle->ejected_event_cb.user_data); + } else { + _ERR("The callback not exists"); + } + break; } default: _ERR("Unknown Event"); diff --git a/src/mdg_private.h b/src/mdg_private.h index 532637f..5722993 100755 --- a/src/mdg_private.h +++ b/src/mdg_private.h @@ -149,6 +149,16 @@ typedef struct _request_channel_list_finish_cb_t { void *user_data; /**< User data pointer */ } request_channel_list_finish_cb_t; +typedef struct _invited_event_cb_t { + mdg_invited_event_cb invited_event_cb; /**< User callback to be called */ + void *user_data; /**< User data pointer */ +} invited_event_cb_t; + +typedef struct _ejected_event_cb_t { + mdg_ejected_event_cb ejected_event_cb; /**< User callback to be called */ + void *user_data; /**< User data pointer */ +} ejected_event_cb_t; + /** * @brief The mdg-manager context * @since_tizen 5.0 @@ -170,6 +180,8 @@ typedef struct _mdg_manager_s { receive_file_cb_t receive_file_cb; /**< When it called after sending the device done or timeout */ request_result_cb_t request_result_cb; /**< When it called after sending private commands or timeout */ request_channel_list_finish_cb_t request_channel_list_finish_cb; /**< When it called after sending private commands or timeout */ + invited_event_cb_t invited_event_cb; + ejected_event_cb_t ejected_event_cb; } mdg_manager_s; #define CHECK_HANDLE_IS_VALID(handle) { \ @@ -209,7 +221,7 @@ typedef struct _channel_cb_s { } channel_cb_s; typedef enum { - MDG_EVENT_GROUP_FOUND = 0, + MDG_EVENT_GROUP_FOUND = 100, MDG_EVENT_GROUP_FIND_FINISH, MDG_EVENT_DEVICE_FOUND, MDG_EVENT_DEVICE_FIND_FINISH, @@ -219,11 +231,9 @@ typedef enum { MDG_EVENT_SEND_DATA_FINISH, MDG_EVENT_REQ_CHANNEL_LIST_FINISH, MDG_EVENT_RECEIVE_DATA, - MDG_EVENT_RECEIVE_FILE = 10, + MDG_EVENT_RECEIVE_FILE = 110, MDG_EVENT_SEND_FILE_PROGRESS, MDG_EVENT_SEND_FILE_FINISH, - MDG_EVENT_INVITED, - MDG_EVENT_EJECTED, -} mdg_event_type_e; +} mdg_private_event_type_e; #endif /* __TIZEN_NETWORK_COMMON_MDG_PRIVATE_H__ */ diff --git a/test/mdg-manager.c b/test/mdg-manager.c index f98df4a..83f6c75 100755 --- a/test/mdg-manager.c +++ b/test/mdg-manager.c @@ -570,6 +570,28 @@ static int run_devices_find(MManager *mm, struct menu_data *menu) return RET_SUCCESS; } +void __invited_event_cb(mdg_group_h group, void *user_data) +{ + char *device_id; + char *name; + + mdg_group_info_get_device_id(group, &device_id); + mdg_group_info_get_name(group, &name); + + msgb("device is invited by [%s], Group Name [%s]", device_id, name); +} + +void __ejected_event_cb(mdg_group_h group, void *user_data) +{ + char *device_id; + char *name; + + mdg_group_info_get_device_id(group, &device_id); + mdg_group_info_get_name(group, &name); + + msgb("device is ejected by [%s], Group Name [%s]", device_id, name); +} + void __receive_file_cb(int result, char *device_id, const char *file_path, void *user_data) { msgb("The %s is stored by %s", file_path, device_id); @@ -632,7 +654,8 @@ int run_device_show_local_device(MManager *mm, struct menu_data *menu) device = NULL; } - + mdg_set_invited_event_cb(handle, __invited_event_cb, NULL); + mdg_set_ejected_event_cb(handle, __ejected_event_cb, NULL); mdg_set_receive_file_cb(handle, __receive_file_cb, NULL); return RET_SUCCESS; -- 2.7.4 From c10fa7050051fc12f63dd3aa5896d116716e093f Mon Sep 17 00:00:00 2001 From: Jihoon Jung Date: Thu, 23 Aug 2018 16:17:29 +0900 Subject: [PATCH 04/16] Add precondition Change-Id: Ic81973c496b5ee830f2139ba49f9e1706bdbc8b9 Signed-off-by: Jihoon Jung --- include/mdg.h | 27 --------------------------- src/mdg.c | 53 +++++++++++++++++++++++++++++++++++++++++++++++------ src/mdg_private.h | 2 +- 3 files changed, 48 insertions(+), 34 deletions(-) diff --git a/include/mdg.h b/include/mdg.h index 5f43b12..de144ba 100755 --- a/include/mdg.h +++ b/include/mdg.h @@ -928,33 +928,6 @@ int mdg_device_info_get_device_id(mdg_device_h device, char **device_id); /** - * @brief Gets IP of the device handle. - * - * @since_tizen 5.0 - * @privlevel public - * - * @remarks The @a ip should be released using free(). - * - * @param[in] device Device handle - * @param[out] ip IP address - * - * @return 0 on success, otherwise a negative error value. - * @retval #MDG_ERROR_NONE Successful - * @retval #MDG_ERROR_INVALID_PARAMETER Invalid parameter - * - * @see mdg_device_info_create() - * @see mdg_device_info_clone() - * @see mdg_device_info_destroy() - * @see mdg_device_info_get_device_id() - * @see mdg_device_info_get_device_type() - * @see mdg_device_info_get_model_name() - * - */ -int mdg_device_info_get_addr(mdg_device_h device, char **addr); -int mdg_device_info_get_port(mdg_device_h device, int *port); -int mdg_device_info_get_secure_port(mdg_device_h device, int *secure_port); - -/** * @brief Gets model name of the device handle. * * @since_tizen 5.0 diff --git a/src/mdg.c b/src/mdg.c index d2e83d0..a37b824 100755 --- a/src/mdg.c +++ b/src/mdg.c @@ -63,6 +63,7 @@ EXPORT_API int mdg_deinitialize(mdg_h handle) int ret = MDG_ERROR_NONE; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); CHECK_HANDLE_IS_VALID(handle); _BEGIN(); @@ -210,6 +211,7 @@ EXPORT_API int mdg_device_regist_channel(mdg_h handle, char *channel_id, mdg_manager_s *_handle = handle; mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("channel_id", channel_id, MDG_ERROR_INVALID_PARAMETER); CHECK_HANDLE_IS_VALID(_handle); _BEGIN(); @@ -243,6 +245,11 @@ EXPORT_API int mdg_device_send_response(mdg_h handle, char *device_id, char *cha mdg_manager_s *_handle = handle; mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("device_id", device_id, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("channel_id", channel_id, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("data", data, MDG_ERROR_INVALID_PARAMETER); + cond_expr_ret(msg_id <= 0, MDG_ERROR_INVALID_PARAMETER); + cond_expr_ret(len <= 0, MDG_ERROR_INVALID_PARAMETER); CHECK_HANDLE_IS_VALID(handle); buf = g_try_malloc0(len + 1); @@ -285,6 +292,7 @@ EXPORT_API int mdg_device_unregist_channel(mdg_h handle, char *channel_id) mdg_manager_s *_handle = handle; mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("channel_id", channel_id, MDG_ERROR_INVALID_PARAMETER); CHECK_HANDLE_IS_VALID(handle); _BEGIN(); @@ -301,7 +309,7 @@ EXPORT_API int mdg_device_unregist_channel(mdg_h handle, char *channel_id) } if (is_exist == false) - ret = MDG_ERROR_OPERATION_FAILED; + ret = MDG_ERROR_NO_DATA; if (ret == MDG_ERROR_NONE) { group_call_unregist_channel_sync(_handle->group_proxy, channel_id, &ret, NULL, &error); @@ -332,10 +340,12 @@ EXPORT_API int mdg_device_send_data(mdg_h handle, mdg_manager_s *_handle = handle; mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); - CHECK_HANDLE_IS_VALID(handle); - mdg_device_s *dev = (mdg_device_s *)device; mdg_check_null_ret_error("dev", dev, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("channel_id", channel_id, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("data", data, MDG_ERROR_INVALID_PARAMETER); + cond_expr_ret(len <= 0, MDG_ERROR_INVALID_PARAMETER); + CHECK_HANDLE_IS_VALID(handle); buf = g_try_malloc0(len + 1); if (NULL == buf) { @@ -417,6 +427,7 @@ EXPORT_API int mdg_set_receive_file_cb(mdg_h handle, mdg_manager_s *_handle = handle; mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("ejected_event_cb", receive_cb, MDG_ERROR_INVALID_PARAMETER); CHECK_HANDLE_IS_VALID(handle); _handle->receive_file_cb.receive_cb = receive_cb; @@ -452,6 +463,7 @@ EXPORT_API int mdg_device_get_local_device(mdg_h handle, mdg_manager_s *_handle = handle; mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER); CHECK_HANDLE_IS_VALID(handle); group_call_get_local_device_sync(_handle->group_proxy, &va, NULL, &error); @@ -617,11 +629,11 @@ EXPORT_API int mdg_group_info_clone(mdg_group_h *target, CHECK_FEATURE_SUPPORTED(MDG_FEATURE); - mdg_group_s * src = (mdg_group_s *)source; + mdg_group_s *src = (mdg_group_s *)source; mdg_check_null_ret_error("source", source, MDG_ERROR_INVALID_PARAMETER); - *target = (mdg_group_s *)g_malloc0(sizeof(mdg_group_s)); mdg_check_null_ret_error("target", target, MDG_ERROR_INVALID_PARAMETER); + *target = (mdg_group_s *)g_malloc0(sizeof(mdg_group_s)); mdg_group_s *dst = *target; if (src->device_id) @@ -641,7 +653,7 @@ EXPORT_API int mdg_group_info_destroy(mdg_group_h data) CHECK_FEATURE_SUPPORTED(MDG_FEATURE); - mdg_group_s * group = (mdg_group_s *)data; + mdg_group_s *group = (mdg_group_s *)data; mdg_check_null_ret_error("group", group, MDG_ERROR_INVALID_PARAMETER); if (group->device_id) { @@ -665,6 +677,8 @@ EXPORT_API int mdg_group_info_get_device_id( int ret = MDG_ERROR_NONE; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + mdg_check_null_ret_error("group", group, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("device_id", device_id, MDG_ERROR_INVALID_PARAMETER); *device_id = g_strdup(((mdg_group_s *)group)->device_id); @@ -677,6 +691,8 @@ EXPORT_API int mdg_group_info_get_type(mdg_group_h group, int ret = MDG_ERROR_NONE; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + mdg_check_null_ret_error("group", group, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("type", type, MDG_ERROR_INVALID_PARAMETER); *type = ((mdg_group_s *)group)->type; @@ -689,6 +705,8 @@ EXPORT_API int mdg_group_info_get_name( int ret = MDG_ERROR_NONE; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + mdg_check_null_ret_error("group", group, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("name", name, MDG_ERROR_INVALID_PARAMETER); *name = g_strdup(((mdg_group_s *)group)->group_name); @@ -784,6 +802,8 @@ EXPORT_API int mdg_device_info_get_device_id( int ret = MDG_ERROR_NONE; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("device_id", device_id, MDG_ERROR_INVALID_PARAMETER); *device_id = g_strdup(((mdg_device_s *)device)->device_id); @@ -796,6 +816,8 @@ EXPORT_API int mdg_device_info_get_model_name( int ret = MDG_ERROR_NONE; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("model_name", model_name, MDG_ERROR_INVALID_PARAMETER); *model_name = g_strdup(((mdg_device_s *)device)->model_name); @@ -808,6 +830,8 @@ EXPORT_API int mdg_device_info_get_device_name( int ret = MDG_ERROR_NONE; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("device_name", device_name, MDG_ERROR_INVALID_PARAMETER); *device_name = g_strdup(((mdg_device_s *)device)->device_name); @@ -820,6 +844,8 @@ EXPORT_API int mdg_device_info_get_platform_ver( int ret = MDG_ERROR_NONE; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("platform_ver", platform_ver, MDG_ERROR_INVALID_PARAMETER); *platform_ver = g_strdup(((mdg_device_s *)device)->platform_ver); @@ -832,6 +858,8 @@ EXPORT_API int mdg_device_info_get_vendor_id( int ret = MDG_ERROR_NONE; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("vendor_id", vendor_id, MDG_ERROR_INVALID_PARAMETER); *vendor_id = g_strdup(((mdg_device_s *)device)->vendor_id); @@ -844,6 +872,8 @@ EXPORT_API int mdg_device_info_get_profile( int ret = MDG_ERROR_NONE; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("profile", profile, MDG_ERROR_INVALID_PARAMETER); *profile = g_strdup(((mdg_device_s *)device)->profile); @@ -856,6 +886,8 @@ EXPORT_API int mdg_device_info_is_invited( int ret = MDG_ERROR_NONE; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("is_invited", is_invited, MDG_ERROR_INVALID_PARAMETER); *is_invited = ((mdg_device_s *)device)->is_invited; @@ -868,6 +900,8 @@ EXPORT_API int mdg_device_info_get_type( int ret = MDG_ERROR_NONE; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("type", type, MDG_ERROR_INVALID_PARAMETER); *type = ((mdg_device_s *)device)->type; @@ -1015,6 +1049,7 @@ EXPORT_API int mdg_request_result_callback(mdg_h handle, mdg_manager_s *_handle = handle; mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + CHECK_HANDLE_IS_VALID(handle); _handle->request_result_cb.result_cb = result_cb; _handle->request_result_cb.user_data = user_data; @@ -1029,6 +1064,8 @@ EXPORT_API int mdg_set_invited_event_cb(mdg_h handle, mdg_invited_event_cb invit mdg_manager_s *_handle = handle; mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("invited_event_cb", invited_event_cb, MDG_ERROR_INVALID_PARAMETER); + CHECK_HANDLE_IS_VALID(handle); _handle->invited_event_cb.invited_event_cb = invited_event_cb; _handle->invited_event_cb.user_data = user_data; @@ -1044,6 +1081,7 @@ EXPORT_API int mdg_unset_invited_event_cb(mdg_h handle) mdg_manager_s *_handle = handle; mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + CHECK_HANDLE_IS_VALID(handle); _handle->invited_event_cb.invited_event_cb = NULL; _handle->invited_event_cb.user_data = NULL; @@ -1059,6 +1097,8 @@ EXPORT_API int mdg_set_ejected_event_cb(mdg_h handle, mdg_ejected_event_cb eject mdg_manager_s *_handle = handle; mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("ejected_event_cb", ejected_event_cb, MDG_ERROR_INVALID_PARAMETER); + CHECK_HANDLE_IS_VALID(handle); _handle->ejected_event_cb.ejected_event_cb = ejected_event_cb; _handle->ejected_event_cb.user_data = user_data; @@ -1074,6 +1114,7 @@ EXPORT_API int mdg_unset_ejected_event_cb(mdg_h handle) mdg_manager_s *_handle = handle; mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + CHECK_HANDLE_IS_VALID(handle); _handle->ejected_event_cb.ejected_event_cb = NULL; _handle->ejected_event_cb.user_data = NULL; diff --git a/src/mdg_private.h b/src/mdg_private.h index 5722993..b0d622e 100755 --- a/src/mdg_private.h +++ b/src/mdg_private.h @@ -186,7 +186,7 @@ typedef struct _mdg_manager_s { #define CHECK_HANDLE_IS_VALID(handle) { \ if (g_slist_find(handle_list, handle) == NULL) \ - return MDG_ERROR_OPERATION_FAILED; \ + return MDG_ERROR_NO_DATA; \ } /** -- 2.7.4 From 3777bd3a33ee27127171ea76474d0940ca82ae23 Mon Sep 17 00:00:00 2001 From: Abhishek Sansanwal Date: Mon, 27 Aug 2018 11:48:28 +0530 Subject: [PATCH 05/16] Return fail if found invited device list or channel list empty Signed-off-by: Abhishek Sansanwal Change-Id: I6fb7f21406e5d548b39d1de8e2ec053eae189f13 --- test/mdg-manager.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/test/mdg-manager.c b/test/mdg-manager.c index 83f6c75..f724307 100755 --- a/test/mdg-manager.c +++ b/test/mdg-manager.c @@ -817,6 +817,12 @@ static int __send_data(int devidx, int chaidx) char *address = NULL; mdg_device_h device = NULL; channel_t *channel = NULL; + + if (!found_invited_device_list || !found_channel_list) { + msgr("Find local device first"); + return RET_FAILURE; + } + if (found_invited_device_list) { device = g_list_nth_data(found_invited_device_list, devidx - 1); if (NULL == device) { -- 2.7.4 From 1b8c5a5239de4b167427b8639ba3609081efe2d4 Mon Sep 17 00:00:00 2001 From: Jihoon Jung Date: Wed, 29 Aug 2018 15:35:28 +0900 Subject: [PATCH 06/16] Add set preconfigured pin Signed-off-by: Jihoon Jung Change-Id: I8f82a7844ccbad378cb056fd5d7e82e8401683d9 --- include/mdg_internal.h | 1 + src/mdg.c | 16 ++++++++++++++++ src/mdg_gdbus.xml | 4 ++++ test/mdg-manager.c | 18 ++++++++++++++++++ 4 files changed, 39 insertions(+) diff --git a/include/mdg_internal.h b/include/mdg_internal.h index 9eee306..21a9e8e 100755 --- a/include/mdg_internal.h +++ b/include/mdg_internal.h @@ -37,6 +37,7 @@ typedef void (*mdg_receive_file_cb)(int result, char *device_id, int mdg_set_receive_file_cb(mdg_h handle, mdg_receive_file_cb receive_cb, void *user_data); int mdg_unset_receive_file_cb(mdg_h handle); +int mdg_set_preconfigured_pin(mdg_h handle, char *password); #ifdef __cplusplus diff --git a/src/mdg.c b/src/mdg.c index a37b824..735f1a0 100755 --- a/src/mdg.c +++ b/src/mdg.c @@ -452,6 +452,22 @@ EXPORT_API int mdg_unset_receive_file_cb(mdg_h handle) return ret; } +EXPORT_API int mdg_set_preconfigured_pin(mdg_h handle, char *password) +{ + int ret = MDG_ERROR_NONE; + GError *error = NULL; + + CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + + mdg_manager_s *_handle = handle; + mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + CHECK_HANDLE_IS_VALID(handle); + + group_call_set_preconfigured_pin_sync(_handle->group_proxy, password, &ret, NULL, &error); + + return ret; +} + EXPORT_API int mdg_device_get_local_device(mdg_h handle, mdg_device_h *device) { diff --git a/src/mdg_gdbus.xml b/src/mdg_gdbus.xml index 0f72d56..966828b 100755 --- a/src/mdg_gdbus.xml +++ b/src/mdg_gdbus.xml @@ -98,6 +98,10 @@ + + + + diff --git a/test/mdg-manager.c b/test/mdg-manager.c index f724307..ae23531 100755 --- a/test/mdg-manager.c +++ b/test/mdg-manager.c @@ -1267,6 +1267,17 @@ static int run_unregist_channel(MManager *mm, struct menu_data *menu) return RET_SUCCESS; } +static int run_set_preconfigured_pin(MManager *mm, struct menu_data *menu) +{ + int ret = 0; + + ret = mdg_set_preconfigured_pin(handle, pin); + + msg(" - mdg_set_preconfigured_pin() ret: [0x%X] [%s]", ret, mdg_error_to_string(ret)); + + return RET_SUCCESS; +} + static struct menu_data menu_group_create[] = { { "0", "Group Name", NULL, NULL, groupid }, { "1", "Run", NULL, run_group_create, NULL }, @@ -1388,6 +1399,12 @@ static struct menu_data menu_unregist_channel[] = { { NULL, NULL, }, }; +static struct menu_data menu_set_preconfigured_pin[] = { + { "0", "PIN", NULL, NULL, pin }, + { "1", "Run", NULL, run_set_preconfigured_pin, NULL }, + { NULL, NULL, }, +}; + struct menu_data menu_mdg_manager[] = { { "1", "Show Local Device", NULL, run_device_show_local_device, NULL }, // O { "2", "Create Group", menu_group_create, NULL, NULL }, // 0 @@ -1409,4 +1426,5 @@ struct menu_data menu_mdg_manager[] = { { "18", "Unregist Channel", menu_unregist_channel, NULL, NULL }, { "19", "Send Message", menu_send_data, NULL, NULL }, // 0 { "20", "Send File", menu_send_file, NULL, NULL }, // 0 + { "21", "Set Preconfigured PIN", menu_set_preconfigured_pin, NULL, NULL }, // 0 }; -- 2.7.4 From 58147974addc5264b4359e87b87e132c37e273c9 Mon Sep 17 00:00:00 2001 From: Jihoon Jung Date: Fri, 7 Sep 2018 15:29:14 +0900 Subject: [PATCH 07/16] Add preconditions Change-Id: Ic8765b2eaaddf6cd3f0176259f3d9acaa7defa0b Signed-off-by: Jihoon Jung --- src/mdg.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/src/mdg.c b/src/mdg.c index 735f1a0..3fccf4c 100755 --- a/src/mdg.c +++ b/src/mdg.c @@ -347,6 +347,8 @@ EXPORT_API int mdg_device_send_data(mdg_h handle, cond_expr_ret(len <= 0, MDG_ERROR_INVALID_PARAMETER); CHECK_HANDLE_IS_VALID(handle); + cond_expr_ret(dev->type == MDG_DEVICE_TYPE_LOCAL, MDG_ERROR_NOT_PROPER_DEVICE); + buf = g_try_malloc0(len + 1); if (NULL == buf) { /* LCOV_EXCL_START */ @@ -400,6 +402,8 @@ EXPORT_API int mdg_device_send_file(mdg_h handle, mdg_device_h device, mdg_check_null_ret_error("dev", dev, MDG_ERROR_INVALID_PARAMETER); mdg_check_null_ret_error("file_path", file_path, MDG_ERROR_INVALID_PARAMETER); + cond_expr_ret(dev->type == MDG_DEVICE_TYPE_LOCAL, MDG_ERROR_NOT_PROPER_DEVICE); + mdg_device_h cloned_device = NULL; mdg_device_info_clone(&cloned_device, device); @@ -508,6 +512,8 @@ EXPORT_API int mdg_group_delete(mdg_h handle, mdg_group_h group) mdg_group_s *grp = (mdg_group_s *)group; mdg_check_null_ret_error("grp", grp, MDG_ERROR_INVALID_PARAMETER); + cond_expr_ret(grp->type == MDG_GROUP_TYPE_REMOTE, MDG_ERROR_NOT_PROPER_GROUP); + /* create group to daemon using gdbus */ group_call_delete_sync(_handle->group_proxy, grp->group_name, &ret, NULL, &error); @@ -531,6 +537,8 @@ EXPORT_API int mdg_group_foreach_device(mdg_h handle, mdg_group_h group, mdg_group_s *grp = (mdg_group_s *)group; mdg_check_null_ret_error("grp", grp, MDG_ERROR_INVALID_PARAMETER); + cond_expr_ret(grp->type == MDG_GROUP_TYPE_REMOTE, MDG_ERROR_NOT_PROPER_GROUP); + group_call_foreach_device_sync(_handle->group_proxy, grp->group_name, &ret, &va, NULL, &error); count = g_variant_n_children(va); @@ -577,6 +585,10 @@ EXPORT_API int mdg_group_invite_device(mdg_h handle, mdg_device_s *dev = (mdg_device_s *)device; mdg_check_null_ret_error("dev", dev, MDG_ERROR_INVALID_PARAMETER); + cond_expr_ret(grp->type == MDG_GROUP_TYPE_REMOTE, MDG_ERROR_NOT_PROPER_GROUP); + cond_expr_ret(dev->type == MDG_DEVICE_TYPE_LOCAL, MDG_ERROR_NOT_PROPER_DEVICE); + cond_expr_ret(dev->is_invited == true, MDG_ERROR_NOT_PROPER_DEVICE); + mdg_device_h cloned_device = NULL; mdg_device_info_clone(&cloned_device, device); @@ -611,6 +623,10 @@ EXPORT_API int mdg_group_eject_device(mdg_h handle, mdg_group_s *grp = (mdg_group_s *)group; mdg_check_null_ret_error("grp", grp, MDG_ERROR_INVALID_PARAMETER); + cond_expr_ret(grp->type == MDG_GROUP_TYPE_REMOTE, MDG_ERROR_NOT_PROPER_GROUP); + cond_expr_ret(dev->type == MDG_DEVICE_TYPE_LOCAL, MDG_ERROR_NOT_PROPER_DEVICE); + cond_expr_ret(dev->is_invited == false, MDG_ERROR_NOT_PROPER_DEVICE); + _handle->device_eject_finish_cb.finish_cb = finish_cb; _handle->device_eject_finish_cb.user_data = user_data; @@ -945,6 +961,8 @@ EXPORT_API int mdg_request_create_group(mdg_h handle, mdg_check_null_ret_error("group_name", group_name, MDG_ERROR_INVALID_PARAMETER); + cond_expr_ret(dev->type == MDG_DEVICE_TYPE_LOCAL, MDG_ERROR_NOT_PROPER_DEVICE); + _DBG("Device id : %s", dev->device_id); group_call_request_create_group_sync(_handle->group_proxy, dev->device_id, @@ -975,6 +993,8 @@ EXPORT_API int mdg_request_invite_device(mdg_h handle, mdg_device_s *dev = (mdg_device_s *)device; mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER); + cond_expr_ret(grp->type == MDG_GROUP_TYPE_LOCAL, MDG_ERROR_NOT_PROPER_GROUP); + _DBG("%s", grp->device_id); _DBG("%s", grp->group_name); _DBG("%s", dev->device_id); @@ -1012,6 +1032,8 @@ EXPORT_API int mdg_request_eject_device(mdg_h handle, mdg_device_s *dev = (mdg_device_s *)device; mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER); + cond_expr_ret(grp->type == MDG_GROUP_TYPE_LOCAL, MDG_ERROR_NOT_PROPER_GROUP); + _DBG("%s", grp->device_id); _DBG("%s", grp->group_name); _DBG("%s", dev->device_id); @@ -1041,6 +1063,9 @@ EXPORT_API int mdg_request_channel_list(mdg_h handle, mdg_device_h device, mdg_device_s *dev = (mdg_device_s *)device; mdg_check_null_ret_error("device", device, MDG_ERROR_INVALID_PARAMETER); + + cond_expr_ret(dev->type == MDG_DEVICE_TYPE_LOCAL, MDG_ERROR_NOT_PROPER_DEVICE); + _handle->request_channel_list_finish_cb.finish_cb = finish_cb; _handle->request_channel_list_finish_cb.user_data = user_data; -- 2.7.4 From 7d901becbc4e731a19492afb5a62629acac3a4ff Mon Sep 17 00:00:00 2001 From: Jihoon Jung Date: Thu, 4 Oct 2018 16:53:42 +0900 Subject: [PATCH 08/16] apply indentation Signed-off-by: Jihoon Jung --- include/mdg.h | 91 ++++++++++++++--------------- include/mdg_internal.h | 8 +-- src/mdg_dbus.c | 99 +++++++++++++------------------ src/mdg_dbus.h | 7 +-- src/mdg_debug.h | 99 +++++++++++++++---------------- src/mdg_private.h | 96 +++++++++++++++--------------- src/mdg_util.c | 39 ++++++------- src/mdg_util.h | 7 +-- test/common.h | 2 +- test/menu.c | 51 +++++++++------- test/menu.h | 156 ++++++++++++++++++++++++++++--------------------- 11 files changed, 332 insertions(+), 323 deletions(-) diff --git a/include/mdg.h b/include/mdg.h index de144ba..c1deaac 100755 --- a/include/mdg.h +++ b/include/mdg.h @@ -55,21 +55,21 @@ typedef void *mdg_h; * @since_tizen 5.0 */ typedef enum { - MDG_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */ - MDG_ERROR_IO_ERROR = TIZEN_ERROR_IO_ERROR, /**< I/O error */ + MDG_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */ + MDG_ERROR_IO_ERROR = TIZEN_ERROR_IO_ERROR, /**< I/O error */ MDG_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */ - MDG_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */ + MDG_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */ MDG_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */ - MDG_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */ - MDG_ERROR_OPERATION_FAILED = TIZEN_ERROR_MDG | 0x01, /**< operation failed */ - MDG_ERROR_NO_DATA = TIZEN_ERROR_MDG | 0x02, /**< Data not exists */ - MDG_ERROR_ALREADY_REGISTERED = TIZEN_ERROR_MDG | 0x03, /**< Request already registered */ - MDG_ERROR_IN_PROGRESS = TIZEN_ERROR_MDG | 0x04,/**< operation is in progress */ - MDG_ERROR_COMM_ERROR = TIZEN_ERROR_MDG | 0x05, /**< communication error in lower layer */ - MDG_ERROR_NOT_STARTED = TIZEN_ERROR_MDG | 0x06, /**< Service Not Started */ - MDG_ERROR_DB = TIZEN_ERROR_MDG | 0x07, /**< Internal DB error */ - MDG_ERROR_NOT_PROPER_GROUP = TIZEN_ERROR_MDG | 0x08, /**< Not proper group */ - MDG_ERROR_NOT_PROPER_DEVICE = TIZEN_ERROR_MDG | 0x09, /**< Not proper device */ + MDG_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */ + MDG_ERROR_OPERATION_FAILED = TIZEN_ERROR_MDG | 0x01, /**< operation failed */ + MDG_ERROR_NO_DATA = TIZEN_ERROR_MDG | 0x02, /**< Data not exists */ + MDG_ERROR_ALREADY_REGISTERED = TIZEN_ERROR_MDG | 0x03, /**< Request already registered */ + MDG_ERROR_IN_PROGRESS = TIZEN_ERROR_MDG | 0x04, /**< operation is in progress */ + MDG_ERROR_COMM_ERROR = TIZEN_ERROR_MDG | 0x05, /**< communication error in lower layer */ + MDG_ERROR_NOT_STARTED = TIZEN_ERROR_MDG | 0x06, /**< Service Not Started */ + MDG_ERROR_DB = TIZEN_ERROR_MDG | 0x07, /**< Internal DB error */ + MDG_ERROR_NOT_PROPER_GROUP = TIZEN_ERROR_MDG | 0x08, /**< Not proper group */ + MDG_ERROR_NOT_PROPER_DEVICE = TIZEN_ERROR_MDG | 0x09, /**< Not proper device */ } mdg_error_e; typedef enum { @@ -146,7 +146,6 @@ int mdg_deinitialize(mdg_h handle); * @} */ - /** * @addtogroup CAPI_NETWORK_MDG_GROUP_MODULE * @{ @@ -158,7 +157,7 @@ int mdg_deinitialize(mdg_h handle); * @since_tizen 5.0 */ typedef enum { - MDG_GROUP_TYPE_LOCAL = 1, /**< Local group */ + MDG_GROUP_TYPE_LOCAL = 1, /**< Local group */ MDG_GROUP_TYPE_REMOTE = 2, /**< Remote grojp */ } mdg_group_type_e; @@ -182,7 +181,7 @@ typedef enum { * @see mdg_group_find() */ typedef bool (*mdg_group_found_cb)(mdg_group_type_e type, - mdg_group_h group, void *user_data); + mdg_group_h group, void *user_data); /** * @brief Called after mdg_group_find() finished. @@ -223,8 +222,8 @@ typedef void (*mdg_group_find_finish_cb)(int result, void *user_data); * */ int mdg_group_find(mdg_h handle, int timeout, - mdg_group_found_cb found_cb, mdg_group_find_finish_cb finish_cb, - void *user_data); + mdg_group_found_cb found_cb, mdg_group_find_finish_cb finish_cb, + void *user_data); /** * @} @@ -326,7 +325,7 @@ typedef bool (*mdg_group_foreach_cb)(mdg_device_h device, void *user_data); * */ int mdg_group_foreach_device(mdg_h handle, mdg_group_h group, - mdg_group_foreach_cb foreach_cb, void *user_data); + mdg_group_foreach_cb foreach_cb, void *user_data); /** * @brief Called after mdg_group_invite_device(). @@ -345,7 +344,7 @@ int mdg_group_foreach_device(mdg_h handle, mdg_group_h group, * @see mdg_group_invite_device() */ typedef void (*mdg_group_invite_device_finish_cb)(int result, - mdg_device_h invited_device, void *user_data); + mdg_device_h invited_device, void *user_data); /** * @brief Called after mdg_group_eject_device(). @@ -394,8 +393,8 @@ typedef void (*mdg_group_eject_device_finish_cb)(int result, void *user_data); * */ int mdg_group_invite_device(mdg_h handle, mdg_group_h group, - mdg_device_h device, char *PIN, - mdg_group_invite_device_finish_cb callback, void *user_data); + mdg_device_h device, char *PIN, + mdg_group_invite_device_finish_cb callback, void *user_data); typedef void (*mdg_invited_event_cb)(mdg_group_h group, void *user_data); int mdg_set_invited_event_cb(mdg_h handle, mdg_invited_event_cb event_cb, void *user_data); @@ -432,9 +431,8 @@ int mdg_unset_ejected_event_cb(mdg_h handle); * */ int mdg_group_eject_device(mdg_h handle, mdg_group_h group, - mdg_device_h device, mdg_group_eject_device_finish_cb callback, - void *user_data); - + mdg_device_h device, mdg_group_eject_device_finish_cb callback, + void *user_data); /** * @} @@ -466,7 +464,7 @@ int mdg_group_eject_device(mdg_h handle, mdg_group_h group, * @see mdg_request_result_callback() */ typedef void (*mdg_request_result_cb)(char *cmd, char *device_id, - unsigned char *arg, int len, int ret, void *user_data); + unsigned char *arg, int len, int ret, void *user_data); typedef void (*mdg_request_channel_list_finish_cb)(char *device_id, char *channel_id, void *user_data); @@ -498,8 +496,8 @@ typedef void (*mdg_request_channel_list_finish_cb)(char *device_id, char *channe * */ int mdg_request_create_group(mdg_h handle, - mdg_device_h device, char *group_name, mdg_request_result_cb cb, - void *user_data); + mdg_device_h device, char *group_name, mdg_request_result_cb cb, + void *user_data); /** * @brief Requests to invite a device to the group. @@ -531,8 +529,8 @@ int mdg_request_create_group(mdg_h handle, * */ int mdg_request_invite_device(mdg_h handle, mdg_group_h group, - mdg_device_h device, char *PIN, mdg_request_result_cb cb, - void *user_data); + mdg_device_h device, char *PIN, mdg_request_result_cb cb, + void *user_data); /** * @brief Requests to eject a device. @@ -561,10 +559,10 @@ int mdg_request_invite_device(mdg_h handle, mdg_group_h group, * */ int mdg_request_eject_device(mdg_h handle, mdg_group_h group, - mdg_device_h device, mdg_request_result_cb cb, void *user_data); + mdg_device_h device, mdg_request_result_cb cb, void *user_data); int mdg_request_channel_list(mdg_h handle, mdg_device_h device, - mdg_request_channel_list_finish_cb finish_cb, void *user_data); + mdg_request_channel_list_finish_cb finish_cb, void *user_data); /** * @} @@ -599,7 +597,7 @@ int mdg_request_channel_list(mdg_h handle, mdg_device_h device, * */ int mdg_group_info_clone(mdg_group_h *dst, - mdg_group_h src); + mdg_group_h src); /** * @brief Destroys the group handle. @@ -677,7 +675,6 @@ int mdg_group_info_get_name(mdg_group_h group, char **name); * @} */ - /** * @addtogroup CAPI_NETWORK_MDG_DEVICE_MODULE * @{ @@ -689,7 +686,7 @@ int mdg_group_info_get_name(mdg_group_h group, char **name); * @since_tizen 5.0 */ typedef enum { - MDG_DEVICE_TYPE_LOCAL = 1, /**< Local device */ + MDG_DEVICE_TYPE_LOCAL = 1, /**< Local device */ MDG_DEVICE_TYPE_REMOTE = 2, /**< Remote device */ } mdg_device_type_e; @@ -730,7 +727,6 @@ typedef bool (*mdg_device_found_cb)(mdg_device_h device, void *user_data); */ typedef void (*mdg_device_find_finish_cb)(int result, void *user_data); - /** * @brief Called after mdg_device_send_data(). * @details Called when the maximum wait time elapsed or after the mdg_device_send_data() @@ -752,7 +748,7 @@ typedef void (*mdg_device_find_finish_cb)(int result, void *user_data); * @see mdg_device_send_data() */ typedef void (*mdg_device_send_data_finish_cb)(int result, mdg_device_h device, - char *channel_id, int msg_id, unsigned char *data, int len, void *user_data); + char *channel_id, int msg_id, unsigned char *data, int len, void *user_data); /** * @brief Gets my local device handle. @@ -796,19 +792,19 @@ int mdg_device_get_local_device(mdg_h handle, mdg_device_h *device); * */ int mdg_device_find(mdg_h handle, int timeout, bool is_invited, - mdg_device_found_cb found_cb, mdg_device_find_finish_cb finish_cb, - void *user_data); + mdg_device_found_cb found_cb, mdg_device_find_finish_cb finish_cb, + void *user_data); typedef void (*mdg_receive_data_cb)(int result, char *device_id, char *channel_id, - int msg_id, unsigned char *data, int len, void *user_data); + int msg_id, unsigned char *data, int len, void *user_data); /* Server Side */ int mdg_device_regist_channel(mdg_h handle, char *channel_id, - mdg_receive_data_cb receive_data_cb, void *user_data); + mdg_receive_data_cb receive_data_cb, void *user_data); /* In 5 seconds */ int mdg_device_send_response(mdg_h handle, char *device_id, char *channel_id, - int msg_id, unsigned char *data, int len); + int msg_id, unsigned char *data, int len); int mdg_device_unregist_channel(mdg_h handle, char *channel_id); @@ -841,8 +837,8 @@ int mdg_device_unregist_channel(mdg_h handle, char *channel_id); * */ int mdg_device_send_data(mdg_h handle, - mdg_device_h device, char *channel_id, unsigned char *data, int len, - mdg_device_send_data_finish_cb finish_cb, void *user_data, int *msg_id); + mdg_device_h device, char *channel_id, unsigned char *data, int len, + mdg_device_send_data_finish_cb finish_cb, void *user_data, int *msg_id); /** * @} @@ -877,7 +873,7 @@ int mdg_device_send_data(mdg_h handle, * */ int mdg_device_info_clone(mdg_device_h *target, - mdg_device_h source); + mdg_device_h source); /** * @brief Destroys the device handle. @@ -925,7 +921,7 @@ int mdg_device_info_destroy(mdg_device_h device); * */ int mdg_device_info_get_device_id(mdg_device_h device, - char **device_id); + char **device_id); /** * @brief Gets model name of the device handle. @@ -981,13 +977,12 @@ int mdg_device_info_is_invited(mdg_device_h device, bool *is_invited); * */ int mdg_device_info_get_type(mdg_device_h device, - mdg_device_type_e *device_type); + mdg_device_type_e *device_type); /** * @} */ - #ifdef __cplusplus } #endif diff --git a/include/mdg_internal.h b/include/mdg_internal.h index 21a9e8e..3df8650 100755 --- a/include/mdg_internal.h +++ b/include/mdg_internal.h @@ -25,24 +25,22 @@ extern "C" { /* File transfer for Client Side */ typedef void (*mdg_send_file_progress_cb)(const char *file_path, long long send_size, - long long total_size, int percent, void *user_data); + long long total_size, int percent, void *user_data); typedef void (*mdg_send_file_finish_cb)(int result, mdg_device_h device, void *user_data); int mdg_device_send_file(mdg_h handle, mdg_device_h device, char *file_path, - mdg_send_file_progress_cb progress_cb, mdg_send_file_finish_cb finish_cb, void *user_data); + mdg_send_file_progress_cb progress_cb, mdg_send_file_finish_cb finish_cb, void *user_data); /* File transfer for Server Side */ typedef void (*mdg_receive_file_cb)(int result, char *device_id, - const char *file_path, void *user_data); + const char *file_path, void *user_data); int mdg_set_receive_file_cb(mdg_h handle, mdg_receive_file_cb receive_cb, void *user_data); int mdg_unset_receive_file_cb(mdg_h handle); int mdg_set_preconfigured_pin(mdg_h handle, char *password); - #ifdef __cplusplus } #endif #endif /* __TIZEN_NETWORK_MULTI_DEVICE_GROUP_MDG_H__ */ - diff --git a/src/mdg_dbus.c b/src/mdg_dbus.c index 556018f..e32dd34 100755 --- a/src/mdg_dbus.c +++ b/src/mdg_dbus.c @@ -15,22 +15,22 @@ * */ -#include -#include -#include #include +#include +#include #include +#include #include -#include #include #include #include #include +#include /* LCOV_EXCL_START */ static void __event_cb(Group *object, - gint event_type, gint ret, GVariant *va, gpointer user_data) + gint event_type, gint ret, GVariant *va, gpointer user_data) { NOTUSED(object); mdg_check_null_ret("user_data", user_data); @@ -42,78 +42,71 @@ static void __event_cb(Group *object, _DBG("Event occured : %d", event_type); switch (event_type) { - case MDG_EVENT_GROUP_FOUND: - { + case MDG_EVENT_GROUP_FOUND: { mdg_group_s *group = NULL; group = mdg_get_group_from_variant(va); if (handle->group_found_cb.found_cb) { handle->group_found_cb.found_cb(group->type, group, - handle->group_found_cb.user_data); + handle->group_found_cb.user_data); } else { _ERR("The callback not exists"); } break; } - case MDG_EVENT_GROUP_FIND_FINISH: - { + case MDG_EVENT_GROUP_FIND_FINISH: { if (handle->group_find_finish_cb.finish_cb) { handle->group_find_finish_cb.finish_cb(ret, - handle->group_find_finish_cb.user_data); + handle->group_find_finish_cb.user_data); } else { _ERR("The callback not exists"); } break; } - case MDG_EVENT_DEVICE_FOUND: - { + case MDG_EVENT_DEVICE_FOUND: { mdg_device_s *device = NULL; device = mdg_get_device_from_variant(va); if (handle->device_found_cb.found_cb) { handle->device_found_cb.found_cb(device, - handle->device_found_cb.user_data); + handle->device_found_cb.user_data); } else { _ERR("The callback not exists"); } break; } - case MDG_EVENT_DEVICE_FIND_FINISH: - { + case MDG_EVENT_DEVICE_FIND_FINISH: { if (handle->device_find_finish_cb.finish_cb) { handle->device_find_finish_cb.finish_cb(ret, - handle->device_find_finish_cb.user_data); + handle->device_find_finish_cb.user_data); } else { _ERR("The callback not exists"); } break; } - case MDG_EVENT_INVITE_DEVICE_FINISH: - { + case MDG_EVENT_INVITE_DEVICE_FINISH: { if (handle->device_invite_finish_cb.finish_cb) { mdg_device_s *device = (mdg_device_s *)(handle->device_invite_finish_cb.device); if (device != NULL) { device->is_invited = true; } handle->device_invite_finish_cb.finish_cb(ret, device, - handle->device_invite_finish_cb.user_data); + handle->device_invite_finish_cb.user_data); } else { _ERR("The callback not exists"); } break; } - case MDG_EVENT_EJECT_DEVICE_FINISH: - { + case MDG_EVENT_EJECT_DEVICE_FINISH: { if (handle->device_eject_finish_cb.finish_cb) { handle->device_eject_finish_cb.finish_cb(ret, - handle->device_eject_finish_cb.user_data); + handle->device_eject_finish_cb.user_data); } else { _ERR("The callback not exists"); } break; } - case MDG_EVENT_SEND_DATA_FINISH: - { + case MDG_EVENT_SEND_DATA_FINISH: { char *device_id; char *channel_id; int msg_id; @@ -124,28 +117,26 @@ static void __event_cb(Group *object, mdg_device_s *device = (mdg_device_s *)(handle->send_data_finish_cb.device); if (handle->send_data_finish_cb.finish_cb) { handle->send_data_finish_cb.finish_cb(ret, device, channel_id, msg_id, data, data_len, - handle->send_data_finish_cb.user_data); + handle->send_data_finish_cb.user_data); } else { _ERR("The callback not exists"); } break; } - case MDG_EVENT_REQ_CHANNEL_LIST_FINISH: - { + case MDG_EVENT_REQ_CHANNEL_LIST_FINISH: { char *device_id; char *channel_id; mdg_get_channel_from_variant(va, &device_id, &channel_id); if (handle->request_channel_list_finish_cb.finish_cb) { handle->request_channel_list_finish_cb.finish_cb(device_id, channel_id, - handle->request_channel_list_finish_cb.user_data); + handle->request_channel_list_finish_cb.user_data); } else { _ERR("The callback not exists"); } break; } - case MDG_EVENT_RECEIVE_DATA: - { + case MDG_EVENT_RECEIVE_DATA: { char *device_id; char *channel_id; int msg_id; @@ -164,25 +155,23 @@ static void __event_cb(Group *object, } if (channel != NULL) - channel->cb(0, device_id, channel_id, msg_id, data, data_len, channel->user_data); + channel->cb(0, device_id, channel_id, msg_id, data, data_len, channel->user_data); break; } - case MDG_EVENT_SEND_FILE_PROGRESS: - { + case MDG_EVENT_SEND_FILE_PROGRESS: { if (handle->send_file_cb.progress_cb) { int percent = 0; long long send_size, total_size; char *file_path; mdg_get_progress_from_variant(va, &file_path, &send_size, &total_size, &percent); handle->send_file_cb.progress_cb(file_path, send_size, total_size, percent, - handle->send_file_cb.user_data); + handle->send_file_cb.user_data); } else { _ERR("The callback not exists"); } break; } - case MDG_EVENT_SEND_FILE_FINISH: - { + case MDG_EVENT_SEND_FILE_FINISH: { if (handle->send_file_cb.finish_cb) { mdg_device_s *device = (mdg_device_s *)(handle->send_file_cb.device); handle->send_file_cb.finish_cb(ret, device, handle->send_file_cb.user_data); @@ -191,21 +180,19 @@ static void __event_cb(Group *object, } break; } - case MDG_EVENT_RECEIVE_FILE: - { + case MDG_EVENT_RECEIVE_FILE: { if (handle->receive_file_cb.receive_cb) { char *device_id; char *file_path; mdg_get_receive_file_from_variant(va, &device_id, &file_path); handle->receive_file_cb.receive_cb(ret, device_id, file_path, - handle->receive_file_cb.user_data); + handle->receive_file_cb.user_data); } else { _ERR("The callback not exists"); } break; } - case MDG_EVENT_INVITED: - { + case MDG_EVENT_INVITED: { mdg_group_s *group = NULL; group = mdg_get_group_from_variant(va); @@ -217,8 +204,7 @@ static void __event_cb(Group *object, } break; } - case MDG_EVENT_EJECTED: - { + case MDG_EVENT_EJECTED: { mdg_group_s *group = NULL; group = mdg_get_group_from_variant(va); @@ -246,8 +232,8 @@ static int _enabler_proxy_init(mdg_manager_s *handle) int ret; handle->enabler_proxy = enabler_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM, - G_DBUS_PROXY_FLAGS_NONE, MDG_DBUS_SERVICE, - MDG_DBUS_ENABLER_PATH, NULL, &error); + G_DBUS_PROXY_FLAGS_NONE, MDG_DBUS_SERVICE, + MDG_DBUS_ENABLER_PATH, NULL, &error); if (NULL == handle->enabler_proxy) { /* LCOV_EXCL_START */ if (error != NULL) { @@ -286,7 +272,7 @@ static int _enabler_proxy_init(mdg_manager_s *handle) /* LCOV_EXCL_START */ static void _dbus_name_owner_notify(GObject *object, GParamSpec *pspec, - gpointer *user_data) + gpointer *user_data) { GDBusProxy *proxy = G_DBUS_PROXY(object); gchar *name_owner = g_dbus_proxy_get_name_owner(proxy); @@ -298,7 +284,6 @@ static void _dbus_name_owner_notify(GObject *object, GParamSpec *pspec, if (NULL == name_owner) gdbus_deinitialize(handle); free(name_owner); - } /* LCOV_EXCL_STOP */ @@ -308,12 +293,12 @@ static int _group_proxy_init(mdg_manager_s *handle) GError *error = NULL; handle->group_proxy = group_proxy_new_for_bus_sync( - G_BUS_TYPE_SYSTEM, - G_DBUS_PROXY_FLAGS_NONE, - MDG_DBUS_SERVICE, - MDG_DBUS_GROUP_PATH, - NULL, - &error); + G_BUS_TYPE_SYSTEM, + G_DBUS_PROXY_FLAGS_NONE, + MDG_DBUS_SERVICE, + MDG_DBUS_GROUP_PATH, + NULL, + &error); if (NULL == handle->group_proxy) { /* LCOV_EXCL_START */ if (error != NULL) { @@ -325,7 +310,7 @@ static int _group_proxy_init(mdg_manager_s *handle) } id = g_signal_connect(handle->group_proxy, "notify::g-name-owner", - G_CALLBACK(_dbus_name_owner_notify), handle); + G_CALLBACK(_dbus_name_owner_notify), handle); if (0 == id) { /* LCOV_EXCL_START */ _ERR("g_signal_connect() Fail"); @@ -336,12 +321,11 @@ static int _group_proxy_init(mdg_manager_s *handle) } g_signal_connect(handle->group_proxy, - "event", G_CALLBACK(__event_cb), handle); + "event", G_CALLBACK(__event_cb), handle); return MDG_ERROR_NONE; } - static void _group_proxy_deinit(mdg_manager_s *handle) { g_object_unref(handle->group_proxy); @@ -382,4 +366,3 @@ int gdbus_deinitialize(mdg_manager_s *handle) return ret; } - diff --git a/src/mdg_dbus.h b/src/mdg_dbus.h index 5dcf832..8ba4133 100644 --- a/src/mdg_dbus.h +++ b/src/mdg_dbus.h @@ -21,12 +21,11 @@ #include #ifdef __cplusplus -extern "C" -{ +extern "C" { #endif -#define MDG_DBUS_SERVICE "org.tizen.mdg" /**< For mdg dbus */ -#define MDG_DBUS_GROUP_PATH "/org/tizen/mdg/group" /**< For group dbus */ +#define MDG_DBUS_SERVICE "org.tizen.mdg" /**< For mdg dbus */ +#define MDG_DBUS_GROUP_PATH "/org/tizen/mdg/group" /**< For group dbus */ #define MDG_DBUS_ENABLER_PATH "/org/tizen/mdg/enabler" /**< dbus auto-activation */ int gdbus_initialize(mdg_manager_s *handle); diff --git a/src/mdg_debug.h b/src/mdg_debug.h index 01b1bd4..07087fe 100644 --- a/src/mdg_debug.h +++ b/src/mdg_debug.h @@ -23,14 +23,14 @@ #define NOTUSED(var) (var = var) #define COLOR_BLACK "\033[0;30m" -#define COLOR_RED "\033[0;31m" +#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_GRAY "\033[0;37m" -#define COLOR_END "\033[0;m" +#define COLOR_BLUE "\033[0;34m" +#define COLOR_PURPLE "\033[0;35m" +#define COLOR_CYAN "\033[0;36m" +#define COLOR_GRAY "\033[0;37m" +#define COLOR_END "\033[0;m" #ifdef LOG_TAG #undef LOG_TAG @@ -38,72 +38,73 @@ #define LOG_TAG "MDG_CAPI" -#define _ERR(fmt, ...) \ - do { \ +#define _ERR(fmt, ...) \ + do { \ LOGE(COLOR_RED fmt COLOR_END, ##__VA_ARGS__); \ } while (0) -#define _INFO(fmt, ...) \ - do { \ +#define _INFO(fmt, ...) \ + do { \ LOGI(COLOR_GREEN fmt COLOR_END, ##__VA_ARGS__); \ } while (0) -#define _WARN(fmt, ...) \ - do { \ +#define _WARN(fmt, ...) \ + do { \ LOGI(COLOR_BROWN fmt COLOR_END, ##__VA_ARGS__); \ } while (0) -#define _DBG(fmt, ...) \ - do { \ +#define _DBG(fmt, ...) \ + do { \ LOGD(fmt, ##__VA_ARGS__); \ } while (0) -#define _BEGIN() \ - do { \ +#define _BEGIN() \ + do { \ LOGD(COLOR_BLUE "BEGIN >>>>" COLOR_END); \ } while (0) -#define _END() \ - do { \ +#define _END() \ + do { \ LOGD(COLOR_BLUE "END <<<<" COLOR_END); \ } while (0) -#define cond_expr_ret(expr, val) \ - do { \ - if (expr) { \ +#define cond_expr_ret(expr, val) \ + do { \ + if (expr) { \ _ERR("[precond fail] expr : %s, ret : %d\n", #expr, val); \ - return (val); \ - } \ + return (val); \ + } \ } while (0) -#define cond_ret(val) \ - do { \ - if (val) { \ +#define cond_ret(val) \ + do { \ + if (val) { \ _ERR("[precond fail] ret : %d\n", val); \ - return (val); \ - } \ + return (val); \ + } \ } while (0) -#define mdg_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 mdg_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 PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args) -#define TC_PRT(format, args...) PRT(format"\n", ##args) +#define mdg_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 mdg_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 PRT(format, args...) printf("%s:%d() " format, __FUNCTION__, __LINE__, ##args) +#define TC_PRT(format, args...) PRT(format "\n", ##args) #endif /* __TIZEN_NETWORK_MDG_DEBUG_H__ */ diff --git a/src/mdg_private.h b/src/mdg_private.h index b0d622e..53f2e84 100755 --- a/src/mdg_private.h +++ b/src/mdg_private.h @@ -18,49 +18,50 @@ #ifndef __TIZEN_NETWORK_COMMON_MDG_PRIVATE_H__ #define __TIZEN_NETWORK_COMMON_MDG_PRIVATE_H__ -#include #include +#include #include -#include -#include #include +#include +#include #include #define MDG_FEATURE "http://tizen.org/feature/network.mdg" -#define CHECK_INPUT_PARAMETER(arg) \ - if (arg == NULL) { \ +#define CHECK_INPUT_PARAMETER(arg) \ + if (arg == NULL) { \ mdg_supported("INVALID_PARAMETER"); \ return MDG_ERROR_INVALID_PARAMETER; \ } #if 0 -#define CHECK_FEATURE_SUPPORTED(feature_name) { \ - bool mdg_supported = FALSE; \ - if (!system_info_get_platform_bool(feature_name, &mdg_supported)) { \ - if (mdg_supported == FALSE) { \ - _WARN("Multi Device Group Manager feature is disabled"); \ - return MDG_ERROR_NOT_SUPPORTED; \ - } \ - } else { \ - _ERR("Error - Feature getting from System Info"); \ - return MDG_ERROR_NOT_SUPPORTED; \ - } \ -} +#define CHECK_FEATURE_SUPPORTED(feature_name) \ + { \ + bool mdg_supported = FALSE; \ + if (!system_info_get_platform_bool(feature_name, &mdg_supported)) { \ + if (mdg_supported == FALSE) { \ + _WARN("Multi Device Group Manager feature is disabled"); \ + return MDG_ERROR_NOT_SUPPORTED; \ + } \ + } else { \ + _ERR("Error - Feature getting from System Info"); \ + return MDG_ERROR_NOT_SUPPORTED; \ + } \ + } #else -#define CHECK_FEATURE_SUPPORTED(feature_name) { \ +#define CHECK_FEATURE_SUPPORTED(feature_name) \ + { \ _WARN("[Feature] Should be check !"); \ } #endif - /** * @brief New group found callback structure * @since_tizen 5.0 */ typedef struct _group_found_cb_t { mdg_group_found_cb found_cb; /**< User callback to be called */ - void *user_data; /**< User data pointer */ + void *user_data; /**< User data pointer */ } group_found_cb_t; /** @@ -69,7 +70,7 @@ typedef struct _group_found_cb_t { */ typedef struct _device_found_cb_t { mdg_device_found_cb found_cb; /**< User callback to be called */ - void *user_data; /**< User data pointer */ + void *user_data; /**< User data pointer */ } device_found_cb_t; /** @@ -78,7 +79,7 @@ typedef struct _device_found_cb_t { */ typedef struct _group_find_finish_cb_t { mdg_group_find_finish_cb finish_cb; /**< User callback to be called */ - void *user_data; /**< User data pointer */ + void *user_data; /**< User data pointer */ } group_find_finish_cb_t; /** @@ -106,7 +107,7 @@ typedef struct _device_invite_finish_cb_t { */ typedef struct _device_eject_finish_cb_t { mdg_group_eject_device_finish_cb finish_cb; /**< User callback to be called */ - void *user_data; /**< User data pointer */ + void *user_data; /**< User data pointer */ } device_eject_finish_cb_t; /** @@ -125,14 +126,14 @@ typedef struct _send_data_finish_cb_t { */ typedef struct _send_file_cb_t { mdg_send_file_progress_cb progress_cb; /**< User callback to be called */ - mdg_send_file_finish_cb finish_cb; /**< User callback to be called */ + mdg_send_file_finish_cb finish_cb; /**< User callback to be called */ mdg_device_h device; void *user_data; /**< User data pointer */ } send_file_cb_t; typedef struct _receive_file_cb_t { mdg_receive_file_cb receive_cb; /**< User callback to be called */ - void *user_data; /**< User data pointer */ + void *user_data; /**< User data pointer */ } receive_file_cb_t; /** @@ -141,22 +142,22 @@ typedef struct _receive_file_cb_t { */ typedef struct _request_result_cb_t { mdg_request_result_cb result_cb; /**< User callback to be called */ - void *user_data; /**< User data pointer */ + void *user_data; /**< User data pointer */ } request_result_cb_t; typedef struct _request_channel_list_finish_cb_t { mdg_request_channel_list_finish_cb finish_cb; /**< User callback to be called */ - void *user_data; /**< User data pointer */ + void *user_data; /**< User data pointer */ } request_channel_list_finish_cb_t; typedef struct _invited_event_cb_t { mdg_invited_event_cb invited_event_cb; /**< User callback to be called */ - void *user_data; /**< User data pointer */ + void *user_data; /**< User data pointer */ } invited_event_cb_t; typedef struct _ejected_event_cb_t { mdg_ejected_event_cb ejected_event_cb; /**< User callback to be called */ - void *user_data; /**< User data pointer */ + void *user_data; /**< User data pointer */ } ejected_event_cb_t; /** @@ -164,38 +165,39 @@ typedef struct _ejected_event_cb_t { * @since_tizen 5.0 */ typedef struct _mdg_manager_s { - Group *group_proxy; /**< To receive signal from cmdgd */ - Enabler *enabler_proxy; /**< Enbler proxy */ + Group *group_proxy; /**< To receive signal from cmdgd */ + Enabler *enabler_proxy; /**< Enbler proxy */ GDBusConnection *system_bus; /**< GDBus System Bus */ GSList *channel_cb_list; - group_found_cb_t group_found_cb; /**< When it called after finding a every single group */ - group_find_finish_cb_t group_find_finish_cb; /**< When it called the group finging time is up */ - device_found_cb_t device_found_cb; /**< When it called after finding a every single device */ - device_find_finish_cb_t device_find_finish_cb; /**< When it called the device finging time is up */ - device_invite_finish_cb_t device_invite_finish_cb; /**< When it called after invinting a device done or timeout */ - device_eject_finish_cb_t device_eject_finish_cb; /**< When it called after ejecting the device done or timeout */ - send_data_finish_cb_t send_data_finish_cb; /**< When it called after sending the device done or timeout */ - send_file_cb_t send_file_cb; /**< When it called after sending the device done or timeout */ - receive_file_cb_t receive_file_cb; /**< When it called after sending the device done or timeout */ - request_result_cb_t request_result_cb; /**< When it called after sending private commands or timeout */ + group_found_cb_t group_found_cb; /**< When it called after finding a every single group */ + group_find_finish_cb_t group_find_finish_cb; /**< When it called the group finging time is up */ + device_found_cb_t device_found_cb; /**< When it called after finding a every single device */ + device_find_finish_cb_t device_find_finish_cb; /**< When it called the device finging time is up */ + device_invite_finish_cb_t device_invite_finish_cb; /**< When it called after invinting a device done or timeout */ + device_eject_finish_cb_t device_eject_finish_cb; /**< When it called after ejecting the device done or timeout */ + send_data_finish_cb_t send_data_finish_cb; /**< When it called after sending the device done or timeout */ + send_file_cb_t send_file_cb; /**< When it called after sending the device done or timeout */ + receive_file_cb_t receive_file_cb; /**< When it called after sending the device done or timeout */ + request_result_cb_t request_result_cb; /**< When it called after sending private commands or timeout */ request_channel_list_finish_cb_t request_channel_list_finish_cb; /**< When it called after sending private commands or timeout */ invited_event_cb_t invited_event_cb; ejected_event_cb_t ejected_event_cb; } mdg_manager_s; -#define CHECK_HANDLE_IS_VALID(handle) { \ - if (g_slist_find(handle_list, handle) == NULL) \ - return MDG_ERROR_NO_DATA; \ -} +#define CHECK_HANDLE_IS_VALID(handle) \ + { \ + if (g_slist_find(handle_list, handle) == NULL) \ + return MDG_ERROR_NO_DATA; \ + } /** * @brief The group structure * @since_tizen 5.0 */ typedef struct _mdg_group_s { - char *device_id; /**< Device ID of the device has this group resource */ - char *group_name; /**< Group Name (Friendly name) */ + char *device_id; /**< Device ID of the device has this group resource */ + char *group_name; /**< Group Name (Friendly name) */ mdg_group_type_e type; /**< Mine or Remote */ } mdg_group_s; diff --git a/src/mdg_util.c b/src/mdg_util.c index 7f10160..7ee9a25 100755 --- a/src/mdg_util.c +++ b/src/mdg_util.c @@ -15,10 +15,10 @@ * */ #include -#include #include #include #include +#include mdg_group_s *mdg_get_group_from_variant(GVariant *va) { @@ -31,10 +31,10 @@ mdg_group_s *mdg_get_group_from_variant(GVariant *va) mdg_group_s *group = calloc(1, sizeof(mdg_group_s)); if (NULL == group) { - /* LCOV_EXCL_START */ - _ERR("Memory allocation failed"); - return NULL; - /* LCOV_EXCL_STOP */ + /* LCOV_EXCL_START */ + _ERR("Memory allocation failed"); + return NULL; + /* LCOV_EXCL_STOP */ } g_variant_get(va, "a{sv}", &iter); @@ -72,10 +72,10 @@ mdg_device_s *mdg_get_device_from_variant(GVariant *va) mdg_device_s *device = calloc(1, sizeof(mdg_device_s)); if (NULL == device) { - /* LCOV_EXCL_START */ - _ERR("Memory allocation failed"); - return NULL; - /* LCOV_EXCL_STOP */ + /* LCOV_EXCL_START */ + _ERR("Memory allocation failed"); + return NULL; + /* LCOV_EXCL_STOP */ } g_variant_get(va, "a{sv}", &iter); @@ -130,7 +130,7 @@ void mdg_get_channel_from_variant(GVariant *va, char **device_id, char **channel } void mdg_get_data_from_variant(GVariant *va, char **device_id, char **channel_id, - int *msg_id, unsigned char **data, int *data_len) + int *msg_id, unsigned char **data, int *data_len) { GVariantIter *iter = NULL; const gchar *key; @@ -166,7 +166,7 @@ void mdg_get_data_from_variant(GVariant *va, char **device_id, char **channel_id } void mdg_get_progress_from_variant(GVariant *va, char **file_path, - long long *send_size, long long *total_size, int *percent) + long long *send_size, long long *total_size, int *percent) { GVariantIter *iter = NULL; const gchar *key; @@ -213,21 +213,21 @@ GVariant *mdg_create_variant_device(mdg_device_s *device) 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); @@ -235,4 +235,3 @@ GVariant *mdg_create_variant_device(mdg_device_s *device) return va; } - diff --git a/src/mdg_util.h b/src/mdg_util.h index bfead55..c3dde47 100755 --- a/src/mdg_util.h +++ b/src/mdg_util.h @@ -21,8 +21,7 @@ #include #ifdef __cplusplus -extern "C" -{ +extern "C" { #endif GVariant *mdg_create_variant_device(mdg_device_s *device); @@ -30,10 +29,10 @@ mdg_device_s *mdg_get_device_from_variant(GVariant *va); mdg_group_s *mdg_get_group_from_variant(GVariant *va); void mdg_get_channel_from_variant(GVariant *va, char **device_id, char **channel_id); void mdg_get_data_from_variant(GVariant *va, char **device_id, char **channel_id, - int *msg_id, unsigned char **data, int *data_len); + int *msg_id, unsigned char **data, int *data_len); void mdg_get_receive_file_from_variant(GVariant *va, char **device_id, char **file_path); void mdg_get_progress_from_variant(GVariant *va, char **file_path, - long long *send_size, long long *total_size, int *percent); + long long *send_size, long long *total_size, int *percent); #ifdef __cplusplus } diff --git a/test/common.h b/test/common.h index 79f3102..293ebea 100755 --- a/test/common.h +++ b/test/common.h @@ -23,7 +23,7 @@ __BEGIN_DECLS -const char* mdg_error_to_string(mdg_error_e err); +const char *mdg_error_to_string(mdg_error_e err); const char *mdg_group_type_to_string(mdg_group_type_e e); __END_DECLS diff --git a/test/menu.c b/test/menu.c index c217f6b..5ba8dd5 100755 --- a/test/menu.c +++ b/test/menu.c @@ -16,22 +16,22 @@ */ #define _GNU_SOURCE +#include +#include #include #include #include +#include #include -#include -#include #include -#include #include "menu.h" -#define DEFAULT_MENU_MENU "m" -#define DEFAULT_MENU_PREV "p" -#define DEFAULT_MENU_QUIT "q" -#define DEFAULT_MENU_NONE "-" -#define TAB_SPACE " " +#define DEFAULT_MENU_MENU "m" +#define DEFAULT_MENU_PREV "p" +#define DEFAULT_MENU_QUIT "q" +#define DEFAULT_MENU_NONE "-" +#define TAB_SPACE " " struct menu_manager { GQueue *stack; @@ -45,7 +45,6 @@ struct menu_manager { GMainLoop *mainloop; }; - char key_buffer[MENU_DATA_SIZE]; int flag_pid_display = 1; @@ -62,11 +61,14 @@ static void _show_reserved_menu(void) msg(ANSI_COLOR_DARKGRAY HR_SINGLE2 ANSI_COLOR_NORMAL); msg(ANSI_COLOR_DARKGRAY HR_SINGLE2 ANSI_COLOR_NORMAL); msg(ANSI_COLOR_DARKGRAY " [ " ANSI_COLOR_NORMAL "%s" ANSI_COLOR_DARKGRAY - " ] " ANSI_COLOR_NORMAL "Previous menu " , DEFAULT_MENU_PREV); + " ] " ANSI_COLOR_NORMAL "Previous menu ", + DEFAULT_MENU_PREV); msg(ANSI_COLOR_DARKGRAY " [ " ANSI_COLOR_NORMAL "%s" ANSI_COLOR_DARKGRAY - " ] " ANSI_COLOR_NORMAL "Show Menu " , DEFAULT_MENU_MENU); + " ] " ANSI_COLOR_NORMAL "Show Menu ", + DEFAULT_MENU_MENU); msg(ANSI_COLOR_DARKGRAY " [ " ANSI_COLOR_NORMAL "%s" ANSI_COLOR_DARKGRAY - " ] " ANSI_COLOR_NORMAL "Quit " , DEFAULT_MENU_QUIT); + " ] " ANSI_COLOR_NORMAL "Quit ", + DEFAULT_MENU_QUIT); } static void _show_input_ok(void) @@ -79,7 +81,9 @@ static void _show_menu(MManager *m, struct menu_data menu[]) int i = 0; int len = 0; struct menu_data *item; - char title_buf[256] = { 0, }; + char title_buf[256] = { + 0, + }; if (!menu) return; @@ -92,7 +96,7 @@ static void _show_menu(MManager *m, struct menu_data menu[]) if (len > 0) { for (i = 0; i < len; i++) { msgn(ANSI_COLOR_NORMAL " >> " ANSI_COLOR_YELLOW "%s", - (char *)g_queue_peek_nth(m->title_stack, i)); + (char *)g_queue_peek_nth(m->title_stack, i)); } } msg(ANSI_COLOR_NORMAL); @@ -122,8 +126,7 @@ static void _show_menu(MManager *m, struct menu_data menu[]) if (item->callback) item->callback(m, item); } else { - msgn(ANSI_COLOR_DARKGRAY " [" ANSI_COLOR_NORMAL "%3s" - ANSI_COLOR_DARKGRAY "] " ANSI_COLOR_NORMAL, item->key); + msgn(ANSI_COLOR_DARKGRAY " [" ANSI_COLOR_NORMAL "%3s" ANSI_COLOR_DARKGRAY "] " ANSI_COLOR_NORMAL, item->key); } memset(title_buf, 0, 256); @@ -138,7 +141,7 @@ static void _show_menu(MManager *m, struct menu_data menu[]) if (item->data) { msg("%s " ANSI_COLOR_LIGHTBLUE "(%s)" ANSI_COLOR_NORMAL, - title_buf, item->data); + title_buf, item->data); } else if (!g_strcmp0(item->key, "*")) { /* none */ } else { @@ -280,10 +283,12 @@ void *menu_manager_ref_user_data(MManager *mm) } gboolean on_menu_manager_keyboard(GIOChannel *src, GIOCondition con, - gpointer data) + gpointer data) { MManager *mm = data; - char local_buf[MENU_DATA_SIZE + 1] = { 0, }; + char local_buf[MENU_DATA_SIZE + 1] = { + 0, + }; if (fgets(local_buf, MENU_DATA_SIZE, stdin) == NULL) return TRUE; @@ -335,8 +340,12 @@ int is_pid_show() static void _hex_dump(const char *pad, int size, const void *data) { - char buf[255] = {0, }; - char hex[4] = {0, }; + char buf[255] = { + 0, + }; + char hex[4] = { + 0, + }; int i; unsigned char *p; diff --git a/test/menu.h b/test/menu.h index fcfcfc8..29f8031 100755 --- a/test/menu.h +++ b/test/menu.h @@ -20,82 +20,106 @@ __BEGIN_DECLS -#define ANSI_COLOR_NORMAL "\e[0m" - -#define ANSI_COLOR_BLACK "\e[0;30m" -#define ANSI_COLOR_RED "\e[0;31m" -#define ANSI_COLOR_GREEN "\e[0;32m" -#define ANSI_COLOR_BROWN "\e[0;33m" -#define ANSI_COLOR_BLUE "\e[0;34m" -#define ANSI_COLOR_MAGENTA "\e[0;35m" -#define ANSI_COLOR_CYAN "\e[0;36m" -#define ANSI_COLOR_LIGHTGRAY "\e[0;37m" - -#define ANSI_COLOR_DARKGRAY "\e[1;30m" -#define ANSI_COLOR_LIGHTRED "\e[1;31m" -#define ANSI_COLOR_LIGHTGREEN "\e[1;32m" -#define ANSI_COLOR_YELLOW "\e[1;33m" -#define ANSI_COLOR_LIGHTBLUE "\e[1;34m" +#define ANSI_COLOR_NORMAL "\e[0m" + +#define ANSI_COLOR_BLACK "\e[0;30m" +#define ANSI_COLOR_RED "\e[0;31m" +#define ANSI_COLOR_GREEN "\e[0;32m" +#define ANSI_COLOR_BROWN "\e[0;33m" +#define ANSI_COLOR_BLUE "\e[0;34m" +#define ANSI_COLOR_MAGENTA "\e[0;35m" +#define ANSI_COLOR_CYAN "\e[0;36m" +#define ANSI_COLOR_LIGHTGRAY "\e[0;37m" + +#define ANSI_COLOR_DARKGRAY "\e[1;30m" +#define ANSI_COLOR_LIGHTRED "\e[1;31m" +#define ANSI_COLOR_LIGHTGREEN "\e[1;32m" +#define ANSI_COLOR_YELLOW "\e[1;33m" +#define ANSI_COLOR_LIGHTBLUE "\e[1;34m" #define ANSI_COLOR_LIGHTMAGENTA "\e[1;35m" -#define ANSI_COLOR_LIGHTCYAN "\e[1;36m" -#define ANSI_COLOR_WHITE "\e[1;37m" - - -#define msg(fmt, args...) do { fprintf(stdout, fmt "\n", ##args); \ - fflush(stdout); } while (0) -#define msgn(fmt, args...) do { fprintf(stdout, fmt, ##args); \ - fflush(stdout); } while (0) +#define ANSI_COLOR_LIGHTCYAN "\e[1;36m" +#define ANSI_COLOR_WHITE "\e[1;37m" + +#define msg(fmt, args...) \ + do { \ + fprintf(stdout, fmt "\n", ##args); \ + fflush(stdout); \ + } while (0) +#define msgn(fmt, args...) \ + do { \ + fprintf(stdout, fmt, ##args); \ + fflush(stdout); \ + } while (0) /* Bold (red) */ -#define msgr(fmt, args...) do { fprintf(stdout, ANSI_COLOR_RED fmt \ - ANSI_COLOR_NORMAL "\n", ##args); fflush(stdout); } while (0) +#define msgr(fmt, args...) \ + do { \ + fprintf(stdout, ANSI_COLOR_RED fmt ANSI_COLOR_NORMAL "\n", ##args); \ + fflush(stdout); \ + } while (0) /* Bold (green) */ -#define msgb(fmt, args...) do { fprintf(stdout, ANSI_COLOR_LIGHTGREEN fmt \ - ANSI_COLOR_NORMAL "\n", ##args); fflush(stdout); } while (0) +#define msgb(fmt, args...) \ + do { \ + fprintf(stdout, ANSI_COLOR_LIGHTGREEN fmt ANSI_COLOR_NORMAL "\n", ##args); \ + fflush(stdout); \ + } while (0) /* Property message */ -#define msgp(fmt, args...) do { fprintf(stdout, ANSI_COLOR_LIGHTMAGENTA fmt \ - ANSI_COLOR_NORMAL "\n", ##args); fflush(stdout); } while (0) - -#define msgt(n, fmt, args...) do { fprintf(stdout, "\e[%dC" fmt "\n", \ - 3 + ((n) * 2), ##args); fflush(stdout); } while (0) - -#define pmsg(fmt, args...) do { \ - if (is_pid_show()) \ - fprintf(stdout, "(%5d) ", get_tid()); \ - fprintf(stdout, fmt "\n", ##args); fflush(stdout); } while (0) - -#define pmsgb(fmt, args...) do { \ - if (is_pid_show()) \ - fprintf(stdout, "(%5d) ", get_tid()); \ - fprintf(stdout, ANSI_COLOR_LIGHTGREEN fmt \ - ANSI_COLOR_NORMAL "\n", ##args); fflush(stdout); } while (0) - -#define pmsgt(n, fmt, args...) do { \ - if (is_pid_show()) \ - fprintf(stdout, "(%5d) ", get_tid()); \ - fprintf(stdout, "\e[%dC" fmt "\n", \ - 3 + ((n) * 2), ##args); fflush(stdout); } while (0) +#define msgp(fmt, args...) \ + do { \ + fprintf(stdout, ANSI_COLOR_LIGHTMAGENTA fmt ANSI_COLOR_NORMAL "\n", ##args); \ + fflush(stdout); \ + } while (0) + +#define msgt(n, fmt, args...) \ + do { \ + fprintf(stdout, "\e[%dC" fmt "\n", \ + 3 + ((n)*2), ##args); \ + fflush(stdout); \ + } while (0) + +#define pmsg(fmt, args...) \ + do { \ + if (is_pid_show()) \ + fprintf(stdout, "(%5d) ", get_tid()); \ + fprintf(stdout, fmt "\n", ##args); \ + fflush(stdout); \ + } while (0) + +#define pmsgb(fmt, args...) \ + do { \ + if (is_pid_show()) \ + fprintf(stdout, "(%5d) ", get_tid()); \ + fprintf(stdout, ANSI_COLOR_LIGHTGREEN fmt ANSI_COLOR_NORMAL "\n", ##args); \ + fflush(stdout); \ + } while (0) + +#define pmsgt(n, fmt, args...) \ + do { \ + if (is_pid_show()) \ + fprintf(stdout, "(%5d) ", get_tid()); \ + fprintf(stdout, "\e[%dC" fmt "\n", \ + 3 + ((n)*2), ##args); \ + fflush(stdout); \ + } while (0) #define MENU_DATA_SIZE 255 - - /* * Horizontal Line - width: 65 * .12345678901234567890123456789012345678901234567890. */ -#define HR_SINGLE "----------------------------------------" \ - "-------------------------" -#define HR_DOUBLE "========================================" \ - "=========================" -#define HR_SINGLE2 " ---------------------------------------" \ - "------------------------ " - -#define MAX_WIDTH strlen(HR_SINGLE) -#define MAX_TITLE ((MAX_WIDTH) - 10) -#define POS_MORE ((MAX_WIDTH) - 3) +#define HR_SINGLE "----------------------------------------" \ + "-------------------------" +#define HR_DOUBLE "========================================" \ + "=========================" +#define HR_SINGLE2 " ---------------------------------------" \ + "------------------------ " + +#define MAX_WIDTH strlen(HR_SINGLE) +#define MAX_TITLE ((MAX_WIDTH)-10) +#define POS_MORE ((MAX_WIDTH)-3) #define RET_SUCCESS 0 #define RET_FAILURE -1 @@ -109,13 +133,13 @@ struct menu_data { char *data; }; -MManager* menu_manager_new(struct menu_data items[], GMainLoop *mainloop); +MManager *menu_manager_new(struct menu_data items[], GMainLoop *mainloop); int menu_manager_run(MManager *mm); int menu_manager_set_user_data(MManager *mm, void *user_data); -void* menu_manager_ref_user_data(MManager *mm); +void *menu_manager_ref_user_data(MManager *mm); -gboolean on_menu_manager_keyboard(GIOChannel *src, GIOCondition con, - gpointer data); +gboolean on_menu_manager_keyboard(GIOChannel *src, GIOCondition con, + gpointer data); pid_t get_tid(); void hide_pid(); -- 2.7.4 From 53507abedd4635f01418c1e0fd8bce1ac4cfb49b Mon Sep 17 00:00:00 2001 From: Jihoon Jung Date: Tue, 16 Oct 2018 13:47:49 +0900 Subject: [PATCH 09/16] Fix svace issue Signed-off-by: Jihoon Jung Change-Id: I6c2249a42a4ee8613e2cdcee04ed6e88068cf077 --- src/mdg_util.c | 4 +-- test/mdg-manager.c | 75 +++++++++++++++++++++++++++++------------------------- 2 files changed, 43 insertions(+), 36 deletions(-) diff --git a/src/mdg_util.c b/src/mdg_util.c index 7ee9a25..3d602f6 100755 --- a/src/mdg_util.c +++ b/src/mdg_util.c @@ -64,7 +64,7 @@ mdg_device_s *mdg_get_device_from_variant(GVariant *va) char *platform_ver = NULL; char *vendor_id = NULL; char *profile = NULL; - bool is_invited; + bool is_invited = false; int type = MDG_DEVICE_TYPE_LOCAL; GVariantIter *iter = NULL; const gchar *key; @@ -135,7 +135,7 @@ void mdg_get_data_from_variant(GVariant *va, char **device_id, char **channel_id GVariantIter *iter = NULL; const gchar *key; GVariant *key_value = NULL; - GVariant *data_va; + GVariant *data_va = NULL; GVariantIter *data_iter = NULL; unsigned char byte_data; diff --git a/test/mdg-manager.c b/test/mdg-manager.c index ae23531..be694ef 100755 --- a/test/mdg-manager.c +++ b/test/mdg-manager.c @@ -77,8 +77,7 @@ void receive_request_result(char *cmd, char *device_id, unsigned char *arg, } if (strncmp("COMP_REQ_CREATE_GROUP", cmd, strlen(cmd)) == 0) { - msgp("[CMD] Request Create Group [%s(0x%X)]", mdg_error_to_string(ret), - ret); + msgp("[CMD] Request Create Group [%s(0x%X)]", mdg_error_to_string(ret), ret); if (ret == MDG_ERROR_NONE && arg != NULL) { msgb("Created Group name is %s", arg); run_group_find(NULL, NULL); @@ -93,8 +92,7 @@ void receive_request_result(char *cmd, char *device_id, unsigned char *arg, if (ret == MDG_ERROR_NONE && arg != NULL) msgb("Ejected Device ID is %s", arg); } else if (strncmp("COMP_REQ_DELETE_GROUP", cmd, strlen(cmd)) == 0) { - msgp("[CMD] Request Delete Group [%s(0x%X)]", mdg_error_to_string(ret), - ret); + msgp("[CMD] Request Delete Group [%s(0x%X)]", mdg_error_to_string(ret), ret); if (ret == MDG_ERROR_NONE && arg != NULL) msgb("Deleted Group name is %s", arg); } else if (strncmp("COMP_REQ_SEND_DATA", cmd, strlen(cmd)) == 0) { @@ -112,7 +110,7 @@ void _device_eject_result_cb(int result, void *user_data) static int run_device_eject(MManager *mm, struct menu_data *menu) { int ret; - int idx; + int idx = 1; mdg_group_h group = NULL; mdg_device_h device = NULL; @@ -172,13 +170,15 @@ bool __group_foreach_cb(mdg_device_h device, void *user_data) found_invited_device_list = g_list_append(found_invited_device_list, device); + g_free(device_id); + return true; } static int run_group_foreach_device(MManager *mm, struct menu_data *menu) { int ret; - int idx; + int idx = 1; mdg_group_h group = NULL; msg("Foreach Device"); @@ -225,7 +225,7 @@ void _device_invite_result_cb(int result, mdg_device_h device, void *user_data) static int run_device_invite(MManager *mm, struct menu_data *menu) { int ret; - int idx; + int idx = 1; mdg_group_h group = NULL; mdg_device_h device = NULL; @@ -465,8 +465,8 @@ static int run_group_get_members(MManager *mm, struct menu_data *menu) static int run_group_delete(MManager *mm, struct menu_data *menu) { int ret; - int idx; - mdg_group_h group; + int idx = 1; + mdg_group_h group = NULL; msg("Delete Group"); @@ -503,7 +503,6 @@ void _device_finish_cb(int result, void *user_data) bool _device_found_cb(mdg_device_h device, void *user_data) { - char *addr = NULL; char *device_id = NULL; char *model_name = NULL; mdg_device_type_e device_type; @@ -540,8 +539,6 @@ bool _device_found_cb(mdg_device_h device, void *user_data) if (device_id) free(device_id); - if (addr) - free(addr); return TRUE; } @@ -549,7 +546,7 @@ bool _device_found_cb(mdg_device_h device, void *user_data) static int run_devices_find(MManager *mm, struct menu_data *menu) { int ret; - int duration; + int duration = 0; msg("Find Devices"); if (strlen(timeout)) @@ -579,6 +576,9 @@ void __invited_event_cb(mdg_group_h group, void *user_data) mdg_group_info_get_name(group, &name); msgb("device is invited by [%s], Group Name [%s]", device_id, name); + + g_free(device_id); + g_free(name); } void __ejected_event_cb(mdg_group_h group, void *user_data) @@ -590,6 +590,9 @@ void __ejected_event_cb(mdg_group_h group, void *user_data) mdg_group_info_get_name(group, &name); msgb("device is ejected by [%s], Group Name [%s]", device_id, name); + + g_free(device_id); + g_free(name); } void __receive_file_cb(int result, char *device_id, const char *file_path, void *user_data) @@ -639,6 +642,8 @@ int run_device_show_local_device(MManager *mm, struct menu_data *menu) msgb("[Is Invited] %d", is_invited); msgb("[Type] %s\n", __device_type_to_string(type)); + if (model_name) + free(model_name); if (device_id) free(device_id); if (device_name) @@ -751,7 +756,7 @@ void _group_finish_cb(int result, void *user_data) static int run_group_find(MManager *mm, struct menu_data *menu) { int ret; - int duration; + int duration = 0; msg("Find Group"); if (strlen(timeout)) @@ -814,7 +819,6 @@ static int __send_data(int devidx, int chaidx) { int ret = 0; char *deviceid = NULL; - char *address = NULL; mdg_device_h device = NULL; channel_t *channel = NULL; @@ -839,22 +843,28 @@ static int __send_data(int devidx, int chaidx) } } + if (NULL == device) { + msgr("device is NULL"); + return RET_FAILURE; + } + + if (NULL == channel) { + msgr("channel is NULL"); + return RET_FAILURE; + } + mdg_device_info_get_device_id(device, &deviceid); msgp("Sent to [ID] %s [CHANNEL ID] %s", deviceid, channel->channel_id); if (deviceid) { free(deviceid); deviceid = NULL; } - if (address) { - free(address); - address = NULL; - } int msg_id; ret = mdg_device_send_data(handle, device, channel->channel_id, (unsigned char *)message, - strlen(message), _send_data_finish_cb, NULL, &msg_id); + strlen(message), _send_data_finish_cb, NULL, &msg_id); if (MDG_ERROR_NONE != ret) - msgr("Failed to Send Data: [ID] %s [IP] %s", deviceid, address); + msgr("Failed to Send Data: [ID] %s", deviceid); msgp("The message ID is %d", msg_id); @@ -901,13 +911,14 @@ void __send_file_finish_cb(int result, mdg_device_h device, void *user_data) mdg_device_info_get_device_id(device, &device_id); msgp("Send file to %s Finished [%s]", device_id, mdg_error_to_string(result)); + + g_free(device_id); } static int __send_file(int devidx) { int ret = 0; char *deviceid = NULL; - char *address = NULL; mdg_device_h device = NULL; if (found_invited_device_list) { @@ -924,15 +935,11 @@ static int __send_file(int devidx) free(deviceid); deviceid = NULL; } - if (address) { - free(address); - address = NULL; - } ret = mdg_device_send_file(handle, device, file_path, __send_file_progress_cb, __send_file_finish_cb, NULL); if (MDG_ERROR_NONE != ret) - msgr("Failed to Send Data: [ID] %s [IP] %s", deviceid, address); + msgr("Failed to Send Data: [ID] %s", deviceid); return ret; } @@ -985,7 +992,7 @@ bool _invited_device_found_cb(mdg_device_h device, void *user_data) static int run_devices_find_invited_device(MManager *mm, struct menu_data *menu) { int ret; - int duration; + int duration = 0; msg("Find My Owned Devices"); if (strlen(timeout)) @@ -1025,7 +1032,7 @@ static int run_request_create_group(MManager *mm, struct menu_data *menu) return RET_SUCCESS; } - int dev_idx; + int dev_idx = 1; if (device_idx != NULL && strlen(device_idx)) { dev_idx = (unsigned short)strtol(device_idx, NULL, 10); if (0 >= dev_idx) { @@ -1072,7 +1079,7 @@ static int run_request_invite(MManager *mm, struct menu_data *menu) return RET_SUCCESS; } - int grp_idx; + int grp_idx = 1; if (group_idx != NULL && strlen(group_idx)) { grp_idx = (unsigned short)strtol(group_idx, NULL, 10); if (0 >= grp_idx) { @@ -1089,7 +1096,7 @@ static int run_request_invite(MManager *mm, struct menu_data *menu) } } - int dev_idx; + int dev_idx = 1; if (device_idx != NULL && strlen(device_idx)) { dev_idx = (unsigned short)strtol(device_idx, NULL, 10); if (0 >= dev_idx) { @@ -1135,7 +1142,7 @@ static int run_request_eject(MManager *mm, struct menu_data *menu) return RET_SUCCESS; } - int grp_idx; + int grp_idx = 1; if (group_idx != NULL && strlen(group_idx)) { grp_idx = (unsigned short)strtol(group_idx, NULL, 10); if (0 >= grp_idx) { @@ -1152,7 +1159,7 @@ static int run_request_eject(MManager *mm, struct menu_data *menu) } } - int dev_idx; + int dev_idx = 1; if (device_idx != NULL && strlen(device_idx)) { dev_idx = (unsigned short)strtol(device_idx, NULL, 10); if (0 >= dev_idx) { @@ -1207,7 +1214,7 @@ static int run_request_channel_list(MManager *mm, struct menu_data *menu) return RET_SUCCESS; } - int dev_idx; + int dev_idx = 1; if (device_idx != NULL && strlen(device_idx)) { dev_idx = (unsigned short)strtol(device_idx, NULL, 10); if (0 >= dev_idx) { -- 2.7.4 From dc6053cd76d8b60669000310385525acbebf3756 Mon Sep 17 00:00:00 2001 From: "saerome.kim" Date: Thu, 31 Jan 2019 18:00:20 +0900 Subject: [PATCH 10/16] Fixed build error for 64 bit architecture Added a licence file added target library symbolic link Change-Id: I77888d97de83b84156881bb3c267bfecd56033a3 Signed-off-by: saerome.kim --- CMakeLists.txt | 11 ++- LICENSE.APLv2 | 204 ++++++++++++++++++++++++++++++++++++++++ packaging/capi-network-mdg.spec | 39 ++++---- test/mdg-manager.c | 4 +- 4 files changed, 236 insertions(+), 22 deletions(-) create mode 100644 LICENSE.APLv2 mode change 100755 => 100644 test/mdg-manager.c diff --git a/CMakeLists.txt b/CMakeLists.txt index 9888373..25c5925 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -59,8 +59,15 @@ SET(SOURCES src/mdg.c ADD_LIBRARY(${CAPI_MDG} SHARED ${SOURCES}) TARGET_LINK_LIBRARIES(${CAPI_MDG} ${${CAPI_MDG}_LDFLAGS} pthread) +SET_TARGET_PROPERTIES(${CAPI_MDG} + PROPERTIES + VERSION ${FULLVER} + SOVERSION ${MAJORVER} + CLEAN_DIRECT_OUTPUT 1 +) + MESSAGE(" - Installing...the library and header files") -INSTALL(TARGETS ${CAPI_MDG} DESTINATION lib) +INSTALL(TARGETS ${CAPI_MDG} DESTINATION ${LIB}) INSTALL( DIRECTORY include/ DESTINATION include FILES_MATCHING @@ -77,6 +84,6 @@ CONFIGURE_FILE( @ONLY ) -INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${CAPI_MDG}.pc DESTINATION lib/pkgconfig) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${CAPI_MDG}.pc DESTINATION ${LIB}/pkgconfig) ADD_SUBDIRECTORY(test) diff --git a/LICENSE.APLv2 b/LICENSE.APLv2 new file mode 100644 index 0000000..26b7de6 --- /dev/null +++ b/LICENSE.APLv2 @@ -0,0 +1,204 @@ +Copyright (c) 2015 Samsung Electronics Co., Ltd. All rights reserved. + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. + diff --git a/packaging/capi-network-mdg.spec b/packaging/capi-network-mdg.spec index 6f6fa7d..b947c2d 100644 --- a/packaging/capi-network-mdg.spec +++ b/packaging/capi-network-mdg.spec @@ -1,6 +1,6 @@ Name: capi-network-mdg Summary: Multi Device Group CAPI -Version: 0.0.1 +Version: 0.1.1 Release: 0 Group: Network & Connectivity/Other License: Apache-2.0 @@ -31,11 +31,9 @@ Requires: %{name} = %{version}-%{release} This package contains the development files for %{name} API library. %prep -%setup -q -chmod 644 %{SOURCE0} -chmod 644 %{SOURCE1} - -cp %{SOURCE1} . +%setup #-q +chmod g-w %_sourcedir/* +cp %{SOURCE1} ./%{name}.manifest %build CFLAGS=$(echo $CFLAGS | sed 's/-O2/-O0/' | sed 's/-O1/-O0/' | sed 's/-Wp,-D_FORTIFY_SOURCE=2//') @@ -50,16 +48,19 @@ MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` %define NETWORK_FW_DATADIR %{TZ_SYS_GLOBALUSER_DATA}/network %define DBDIR %{TZ_SYS_GLOBALUSER_DATA}/ -%cmake . \ - -DMAJORVER=${MAJORVER} -DFULLVER=%{version} \ - -DLIB_DIR=%{_libdir} -DBIN_DIR=%{_bindir} -DSBIN_DIR=%{_sbindir} \ +cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} \ + -DLIB_INSTALL_DIR=%{_libdir} \ + -DBIN_INSTALL_DIR=%{_bindir} \ + -DINCLUDE_INSTALL_DIR=%{_includedir} \ + -DLIB_PATH=%{_lib} \ + -DFULLVER=%{version} \ + -DMAJORVER=${MAJORVER} \ -DNETWORK_FW_DATADIR=%{NETWORK_FW_DATADIR} \ - -DDBDIR=%{DBDIR} -DBUILD_GCOV=%{?gcov:1}%{!?gcov:0} - -make %{?_smp_mflags} + -DDBDIR=%{DBDIR} \ + -DBUILD_GCOV=%{?gcov:1}%{!?gcov:0} %install -rm -rf %{buildroot}/BUILD/%{name}* +rm -rf %{buildroot}/BUILD/%{name} %make_install %post -p /sbin/ldconfig @@ -68,12 +69,14 @@ rm -rf %{buildroot}/BUILD/%{name}* %files -%manifest capi-network-mdg.manifest +%manifest %{name}.manifest %defattr(-,root,root,-) -%{_libdir}/libcapi-network-mdg.so* +%license LICENSE.APLv2 +%attr(644,-,-) %{_libdir}/lib%{name}.so* %files devel +%defattr(-,root,root,-) +%attr(644,-,-) %{_libdir}/lib%{name}.so* +%{_libdir}/pkgconfig/%{name}.pc %{_includedir}/*.h -%{_libdir}/pkgconfig/*.pc -%{_libdir}/libcapi-network-mdg.so -%attr(777,network_fw,network_fw) %{_bindir}/mdg-test +%attr(777,network_fw,network_fw) %{_bindir}/mdg-test \ No newline at end of file diff --git a/test/mdg-manager.c b/test/mdg-manager.c old mode 100755 new mode 100644 index be694ef..2deaffd --- a/test/mdg-manager.c +++ b/test/mdg-manager.c @@ -96,9 +96,9 @@ void receive_request_result(char *cmd, char *device_id, unsigned char *arg, if (ret == MDG_ERROR_NONE && arg != NULL) msgb("Deleted Group name is %s", arg); } else if (strncmp("COMP_REQ_SEND_DATA", cmd, strlen(cmd)) == 0) { - msgp("Received data [%d] %s", strlen((char *)arg), arg); + msgp("Received data [%zd] %s", strlen((char *)arg), arg); } else { - msgp("[Recv][%d] %s", strlen((char *) arg), arg); + msgp("[Recv][%zd] %s", strlen((char *) arg), arg); } } -- 2.7.4 From 3e388a185139d19968f36c15526ad6504a3b5c46 Mon Sep 17 00:00:00 2001 From: "saerome.kim" Date: Thu, 31 Jan 2019 19:48:03 +0900 Subject: [PATCH 11/16] Build configuration cleaned up Change-Id: I7de6a5281ec6ef7dc03be1fc01d03f0a1202a908 Signed-off-by: saerome.kim --- CMakeLists.txt | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 25c5925..1cd5e3a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -23,14 +23,11 @@ pkg_check_modules(${CAPI_MDG} REQUIRED ${COMMON_DEPS}) FOREACH(flag ${${CAPI_MDG}_CFLAGS}) SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") ENDFOREACH(flag) - +SET(DEFAULT_CFLAGS "${EXTRA_CFLAGS} -Wall -fPIE -fPIC -Werror -g -fvisibility=hidden") IF(BUILD_GCOV) - SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror -g -fvisibility=hidden -fprofile-arcs -ftest-coverage") -ELSE(BUILD_GCOV) - SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror -g -fvisibility=hidden") + SET(GCOV_C_FLAGS "-fprofile-arcs -ftest-coverage") ENDIF(BUILD_GCOV) - -SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror -g -fvisibility=hidden") +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${DEFAULT_CFLAGS} ${GCOV_C_FLAGS}") SET(CMAKE_C_FLAGS_DEBUG "-O0 -g") IF("${ARCH}" STREQUAL "arm") @@ -40,7 +37,7 @@ ENDIF("${ARCH}" STREQUAL "arm") ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"") ADD_DEFINITIONS("-DTIZEN_DEBUG") -SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=${LIBDIR}") +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -pie -Wl,--rpath=${LIBDIR}") MESSAGE(" - Generating...d-bus code") FIND_PROGRAM(GDBUS_CODEGEN NAMES gdbus-codegen) -- 2.7.4 From 7e8470061762b7cb9ac7d4ebcff1d697f3a5ca23 Mon Sep 17 00:00:00 2001 From: Jihoon Jung Date: Tue, 26 Feb 2019 13:48:46 +0900 Subject: [PATCH 12/16] Added 'End-point' functionality. - Request remote apps to open end-point. - Once end-point created, client app can send binary data through the end-point. Change-Id: I77f5eb7b9e772b27b0008a77e35de100f410bc40 --- include/mdg.h | 32 +++++++- include/mdg_internal.h | 14 ---- src/mdg.c | 183 ++++++++++++++++++++++++++----------------- src/mdg_dbus.c | 184 +++++++++++++++++++++++++++++++++++--------- src/mdg_gdbus.xml | 5 ++ src/mdg_private.h | 52 ++++++------- src/mdg_util.c | 7 +- src/mdg_util.h | 3 +- test/mdg-manager.c | 205 +++++++++++++++++++++++++++++-------------------- 9 files changed, 449 insertions(+), 236 deletions(-) mode change 100644 => 100755 test/mdg-manager.c diff --git a/include/mdg.h b/include/mdg.h index c1deaac..8b017e2 100755 --- a/include/mdg.h +++ b/include/mdg.h @@ -110,6 +110,13 @@ typedef void *mdg_group_h; /**< Group handle */ */ /** + * @brief Channel handle. + * + * @since_tizen 5.0 + */ +typedef void *mdg_channel_h; /**< Device handle */ + +/** * @brief Initializes mdg-manager. * @since_tizen 5.0 * @privlevel public @@ -690,6 +697,11 @@ typedef enum { MDG_DEVICE_TYPE_REMOTE = 2, /**< Remote device */ } mdg_device_type_e; +typedef enum { + MDG_CHANNEL_TYPE_CLIENT = 1, /**< Client Channel */ + MDG_CHANNEL_TYPE_SERVER = 2, /**< Server Channel */ +} mdg_channel_type_e; + /** * @brief Called after mdg_device_find(). * @details This function can receive a device found. @@ -795,12 +807,12 @@ int mdg_device_find(mdg_h handle, int timeout, bool is_invited, mdg_device_found_cb found_cb, mdg_device_find_finish_cb finish_cb, void *user_data); -typedef void (*mdg_receive_data_cb)(int result, char *device_id, char *channel_id, +typedef void (*mdg_channel_receive_data_cb)(int result, char *device_id, char *channel_id, int msg_id, unsigned char *data, int len, void *user_data); /* Server Side */ int mdg_device_regist_channel(mdg_h handle, char *channel_id, - mdg_receive_data_cb receive_data_cb, void *user_data); + mdg_channel_receive_data_cb receive_data_cb, void *user_data); /* In 5 seconds */ int mdg_device_send_response(mdg_h handle, char *device_id, char *channel_id, @@ -979,6 +991,22 @@ int mdg_device_info_is_invited(mdg_device_h device, bool *is_invited); int mdg_device_info_get_type(mdg_device_h device, mdg_device_type_e *device_type); + +typedef void (*mdg_channel_opened_cb)(int result, mdg_channel_h channel, void *user_data); + +//client side +int mdg_request_channel_open(mdg_h handle, mdg_device_h device, char *channel_id, + mdg_channel_opened_cb opened_cb, void *user_data); + +//server side +int mdg_set_channel_opened_callback(mdg_h handle, char *channel_id, + mdg_channel_opened_cb opened_cb, void *user_data); + +int mdg_channel_write(mdg_channel_h handle, unsigned char *data, int len); + +//polling when write function from another side +int mdg_channel_read(mdg_channel_h handle, unsigned char **data, int *len); + /** * @} */ diff --git a/include/mdg_internal.h b/include/mdg_internal.h index 3df8650..e3fe622 100755 --- a/include/mdg_internal.h +++ b/include/mdg_internal.h @@ -23,20 +23,6 @@ extern "C" { #endif -/* File transfer for Client Side */ -typedef void (*mdg_send_file_progress_cb)(const char *file_path, long long send_size, - long long total_size, int percent, void *user_data); -typedef void (*mdg_send_file_finish_cb)(int result, mdg_device_h device, void *user_data); - -int mdg_device_send_file(mdg_h handle, mdg_device_h device, char *file_path, - mdg_send_file_progress_cb progress_cb, mdg_send_file_finish_cb finish_cb, void *user_data); - -/* File transfer for Server Side */ -typedef void (*mdg_receive_file_cb)(int result, char *device_id, - const char *file_path, void *user_data); - -int mdg_set_receive_file_cb(mdg_h handle, mdg_receive_file_cb receive_cb, void *user_data); -int mdg_unset_receive_file_cb(mdg_h handle); int mdg_set_preconfigured_pin(mdg_h handle, char *password); #ifdef __cplusplus diff --git a/src/mdg.c b/src/mdg.c index 3fccf4c..301d52f 100755 --- a/src/mdg.c +++ b/src/mdg.c @@ -174,27 +174,27 @@ EXPORT_API int mdg_device_find(mdg_h handle, int timeout, bool is_invited, /** * Companion Manager CAPI */ -int __add_channel_cb(mdg_manager_s *handle, char *channel_id, mdg_receive_data_cb channel_cb, void *user_data) +int __add_channel_cb(mdg_manager_s *handle, char *channel_id, mdg_channel_receive_data_cb channel_cb, void *user_data) { - channel_cb_s *channel_s; + mdg_channel_cb_s *channel_s; GSList *l1, *l2; for (l1 = handle_list; l1 != NULL; l1 = l1->next) { mdg_manager_s *tmp_handle = (mdg_manager_s *)l1->data; for (l2 = tmp_handle->channel_cb_list; l2 != NULL; l2 = l2->next) { - channel_cb_s *tmp_channel = (channel_cb_s *)l2->data; + mdg_channel_cb_s *tmp_channel = (mdg_channel_cb_s *)l2->data; if (g_strcmp0(tmp_channel->channel_id, channel_id) == 0) return MDG_ERROR_OPERATION_FAILED; } } - channel_s = g_try_new0(channel_cb_s, 1); + channel_s = g_try_new0(mdg_channel_cb_s, 1); if (channel_s == NULL) return MDG_ERROR_OUT_OF_MEMORY; channel_s->channel_id = g_strdup(channel_id); - channel_s->cb = channel_cb; - channel_s->user_data = user_data; + channel_s->receive_data_cb = channel_cb; + channel_s->receive_data_cb_user_data = user_data; handle->channel_cb_list = g_slist_prepend(handle->channel_cb_list, channel_s); @@ -202,7 +202,7 @@ int __add_channel_cb(mdg_manager_s *handle, char *channel_id, mdg_receive_data_c } EXPORT_API int mdg_device_regist_channel(mdg_h handle, char *channel_id, - mdg_receive_data_cb receive_data_cb, void *user_data) + mdg_channel_receive_data_cb receive_data_cb, void *user_data) { int ret = MDG_ERROR_NONE; GError *error = NULL; @@ -299,7 +299,7 @@ EXPORT_API int mdg_device_unregist_channel(mdg_h handle, char *channel_id) GSList *l; for (l = _handle->channel_cb_list; l != NULL; l = l->next) { - channel_cb_s *tmp_channel = (channel_cb_s *)l->data; + mdg_channel_cb_s *tmp_channel = (mdg_channel_cb_s *)l->data; if (g_strcmp0(tmp_channel->channel_id, channel_id) == 0) { g_free(tmp_channel->channel_id); _handle->channel_cb_list = g_slist_remove_link(_handle->channel_cb_list, l); @@ -325,15 +325,11 @@ EXPORT_API int mdg_device_unregist_channel(mdg_h handle, char *channel_id) return ret; } -EXPORT_API int mdg_device_send_data(mdg_h handle, - mdg_device_h device, char *channel_id, unsigned char *data, int len, - mdg_device_send_data_finish_cb finish_cb, void *user_data, int *msg_id) +//client side +EXPORT_API int mdg_request_channel_open(mdg_h handle, mdg_device_h device, char *channel_id, + mdg_channel_opened_cb opened_cb, void *user_data) { int ret = MDG_ERROR_NONE; - unsigned char *buf = NULL; - GVariantBuilder *bytearray_builder = NULL; - int i; - GVariant *params = NULL; GError *error = NULL; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); @@ -343,115 +339,162 @@ EXPORT_API int mdg_device_send_data(mdg_h handle, mdg_device_s *dev = (mdg_device_s *)device; mdg_check_null_ret_error("dev", dev, MDG_ERROR_INVALID_PARAMETER); mdg_check_null_ret_error("channel_id", channel_id, MDG_ERROR_INVALID_PARAMETER); - mdg_check_null_ret_error("data", data, MDG_ERROR_INVALID_PARAMETER); - cond_expr_ret(len <= 0, MDG_ERROR_INVALID_PARAMETER); CHECK_HANDLE_IS_VALID(handle); cond_expr_ret(dev->type == MDG_DEVICE_TYPE_LOCAL, MDG_ERROR_NOT_PROPER_DEVICE); - buf = g_try_malloc0(len + 1); - if (NULL == buf) { - /* LCOV_EXCL_START */ - _ERR("g_malloc0 is failed"); - return MDG_ERROR_OUT_OF_MEMORY; - /* LCOV_EXCL_STOP */ - } - memcpy(buf, data, len); - - bytearray_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); - for (i = 0; i < len; i++) - g_variant_builder_add(bytearray_builder, "y", buf[i]); - - params = g_variant_new("(iay)", len, bytearray_builder); - g_variant_builder_unref(bytearray_builder); - mdg_device_h cloned_device = NULL; mdg_device_info_clone(&cloned_device, device); - _handle->send_data_finish_cb.finish_cb = finish_cb; - _handle->send_data_finish_cb.user_data = user_data; - _handle->send_data_finish_cb.device = cloned_device; + _handle->request_channel_open_finish_cb.channel_opened_cb = opened_cb; + _handle->request_channel_open_finish_cb.user_data = user_data; + _handle->request_channel_open_finish_cb.device = cloned_device; - group_call_send_data_sync(_handle->group_proxy, dev->device_id, - channel_id, params, &ret, msg_id, NULL, &error); + group_call_request_channel_open_sync(_handle->group_proxy, dev->device_id, + channel_id, &ret, NULL, &error); if (error) { _ERR("Failed DBus call [%s]", error->message); g_error_free(error); ret = MDG_ERROR_IO_ERROR; } - g_free(buf); - buf = NULL; - return ret; } -EXPORT_API int mdg_device_send_file(mdg_h handle, mdg_device_h device, - char *file_path, mdg_send_file_progress_cb progress_cb, mdg_send_file_finish_cb finish_cb, void *user_data) +//server side +EXPORT_API int mdg_set_channel_opened_callback(mdg_h handle, char *channel_id, + mdg_channel_opened_cb opened_cb, void *user_data) { int ret = MDG_ERROR_NONE; - GError *error = NULL; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); mdg_manager_s *_handle = handle; mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("channel_id", channel_id, MDG_ERROR_INVALID_PARAMETER); CHECK_HANDLE_IS_VALID(handle); - mdg_device_s *dev = (mdg_device_s *)device; - mdg_check_null_ret_error("dev", dev, MDG_ERROR_INVALID_PARAMETER); - mdg_check_null_ret_error("file_path", file_path, MDG_ERROR_INVALID_PARAMETER); + mdg_channel_cb_s *channel = NULL; - cond_expr_ret(dev->type == MDG_DEVICE_TYPE_LOCAL, MDG_ERROR_NOT_PROPER_DEVICE); + GSList *l; + for (l = _handle->channel_cb_list; l != NULL; l = l->next) { + mdg_channel_cb_s *tmp_channel = (mdg_channel_cb_s *)l->data; + if (g_strcmp0(tmp_channel->channel_id, channel_id) == 0) { + channel = tmp_channel; + break; + } + } - mdg_device_h cloned_device = NULL; - mdg_device_info_clone(&cloned_device, device); + if (channel == NULL) { + _ERR("The channel is not registered"); + return MDG_ERROR_NO_DATA; + } - _handle->send_file_cb.finish_cb = finish_cb; - _handle->send_file_cb.progress_cb = progress_cb; - _handle->send_file_cb.device = cloned_device; - _handle->send_file_cb.user_data = user_data; + channel->opened_cb = opened_cb; + channel->opened_cb_user_data = user_data; - group_call_send_file_sync(_handle->group_proxy, dev->device_id, file_path, &ret, NULL, &error); - if (error) { - _ERR("Failed DBus call [%s]", error->message); - g_error_free(error); - ret = MDG_ERROR_IO_ERROR; + return ret; +} + +EXPORT_API int mdg_channel_write(mdg_channel_h channel, unsigned char *data, int len) +{ + int ret = MDG_ERROR_NONE; + + CHECK_FEATURE_SUPPORTED(MDG_FEATURE); + + mdg_channel_s *_channel = channel; + mdg_check_null_ret_error("channel", channel, MDG_ERROR_INVALID_PARAMETER); + + ret = write(_channel->client_sockfd, data, len); + if (ret == -1) { + char buf[128]; + strerror_r(errno, buf, 128); + _ERR("write() error : %s", buf); + ret = MDG_ERROR_OPERATION_FAILED; } return ret; } -EXPORT_API int mdg_set_receive_file_cb(mdg_h handle, - mdg_receive_file_cb receive_cb, void *user_data) +//polling function +#define MAXBUF 1024 +EXPORT_API int mdg_channel_read(mdg_channel_h channel, unsigned char **data, int *len) { int ret = MDG_ERROR_NONE; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); - mdg_manager_s *_handle = handle; - mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); - mdg_check_null_ret_error("ejected_event_cb", receive_cb, MDG_ERROR_INVALID_PARAMETER); - CHECK_HANDLE_IS_VALID(handle); + mdg_channel_s *_channel = channel; + mdg_check_null_ret_error("channel", channel, MDG_ERROR_INVALID_PARAMETER); - _handle->receive_file_cb.receive_cb = receive_cb; - _handle->receive_file_cb.user_data = user_data; + *len = read(_channel->client_sockfd, *data, MAXBUF); + if (ret == -1) { + char buf[128]; + strerror_r(errno, buf, 128); + _ERR("read() error : %s", buf); + ret = MDG_ERROR_OPERATION_FAILED; + } return ret; } -EXPORT_API int mdg_unset_receive_file_cb(mdg_h handle) +EXPORT_API int mdg_device_send_data(mdg_h handle, + mdg_device_h device, char *channel_id, unsigned char *data, int len, + mdg_device_send_data_finish_cb finish_cb, void *user_data, int *msg_id) { int ret = MDG_ERROR_NONE; + unsigned char *buf = NULL; + GVariantBuilder *bytearray_builder = NULL; + int i; + GVariant *params = NULL; + GError *error = NULL; CHECK_FEATURE_SUPPORTED(MDG_FEATURE); mdg_manager_s *_handle = handle; mdg_check_null_ret_error("handle", handle, MDG_ERROR_INVALID_PARAMETER); + mdg_device_s *dev = (mdg_device_s *)device; + mdg_check_null_ret_error("dev", dev, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("channel_id", channel_id, MDG_ERROR_INVALID_PARAMETER); + mdg_check_null_ret_error("data", data, MDG_ERROR_INVALID_PARAMETER); + cond_expr_ret(len <= 0, MDG_ERROR_INVALID_PARAMETER); CHECK_HANDLE_IS_VALID(handle); - _handle->receive_file_cb.receive_cb = NULL; - _handle->receive_file_cb.user_data = NULL; + cond_expr_ret(dev->type == MDG_DEVICE_TYPE_LOCAL, MDG_ERROR_NOT_PROPER_DEVICE); + + buf = g_try_malloc0(len + 1); + if (NULL == buf) { + /* LCOV_EXCL_START */ + _ERR("g_malloc0 is failed"); + return MDG_ERROR_OUT_OF_MEMORY; + /* LCOV_EXCL_STOP */ + } + memcpy(buf, data, len); + + bytearray_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); + for (i = 0; i < len; i++) + g_variant_builder_add(bytearray_builder, "y", buf[i]); + + params = g_variant_new("(iay)", len, bytearray_builder); + g_variant_builder_unref(bytearray_builder); + + mdg_device_h cloned_device = NULL; + mdg_device_info_clone(&cloned_device, device); + + _handle->send_data_finish_cb.finish_cb = finish_cb; + _handle->send_data_finish_cb.user_data = user_data; + _handle->send_data_finish_cb.device = cloned_device; + + group_call_send_data_sync(_handle->group_proxy, dev->device_id, + channel_id, params, &ret, msg_id, NULL, &error); + if (error) { + _ERR("Failed DBus call [%s]", error->message); + g_error_free(error); + ret = MDG_ERROR_IO_ERROR; + } + + g_free(buf); + buf = NULL; return ret; } diff --git a/src/mdg_dbus.c b/src/mdg_dbus.c index e32dd34..f10dd00 100755 --- a/src/mdg_dbus.c +++ b/src/mdg_dbus.c @@ -20,6 +20,11 @@ #include #include #include +#include +#include +#include +#include +#include #include #include @@ -127,7 +132,7 @@ static void __event_cb(Group *object, char *device_id; char *channel_id; - mdg_get_channel_from_variant(va, &device_id, &channel_id); + mdg_get_channel_from_variant(va, &device_id, &channel_id, NULL); if (handle->request_channel_list_finish_cb.finish_cb) { handle->request_channel_list_finish_cb.finish_cb(device_id, channel_id, handle->request_channel_list_finish_cb.user_data); @@ -136,6 +141,56 @@ static void __event_cb(Group *object, } break; } + case MDG_EVENT_REQ_CHANNEL_OPEN_FINISH: { + int ret = MDG_ERROR_NONE; + char tempaddr[26] = {0,}; + char *temp_for_strtok = NULL; + char *ret_ptr = NULL; + mdg_channel_s *channel = calloc(1, sizeof(mdg_channel_s)); + if (NULL == channel) { + _ERR("Memory allocation failed"); + ret = MDG_ERROR_OUT_OF_MEMORY; + goto REQUEST_OPEN_CHANNEL_FINISH_EXIT; + } + + mdg_get_channel_from_variant(va, &channel->device_id, &channel->channel_id, + &channel->remote_address); + + /* create socket */ + struct sockaddr_in serveraddr; + channel->client_sockfd = socket(AF_INET, SOCK_STREAM, 0); + if (channel->client_sockfd < 0) { + _ERR("socket() error"); + ret = MDG_ERROR_OPERATION_FAILED; + goto REQUEST_OPEN_CHANNEL_FINISH_EXIT; + } + memset(&serveraddr, 0, sizeof(serveraddr)); + + serveraddr.sin_family = AF_INET; + serveraddr.sin_port = htons(8675); + + sscanf(channel->remote_address, "coaps://%s", (char *)tempaddr); + ret_ptr = strtok_r(tempaddr, ":", &temp_for_strtok); + _ERR("Address is %s", ret_ptr); + + inet_pton(AF_INET, ret_ptr, &serveraddr.sin_addr.s_addr); + ret = connect(channel->client_sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)); + + if (ret == -1) { + _DBG("Connect error : %s", strerror(errno)); + } else { + _DBG("Success Connect to %s", ret_ptr); + } + +REQUEST_OPEN_CHANNEL_FINISH_EXIT: + if (handle->request_channel_open_finish_cb.channel_opened_cb) { + handle->request_channel_open_finish_cb.channel_opened_cb(ret, channel, + handle->request_channel_open_finish_cb.user_data); + } else { + _ERR("The callback not exists"); + } + break; + } case MDG_EVENT_RECEIVE_DATA: { char *device_id; char *channel_id; @@ -145,51 +200,17 @@ static void __event_cb(Group *object, mdg_get_data_from_variant(va, &device_id, &channel_id, &msg_id, &data, &data_len); - channel_cb_s *channel = NULL; + mdg_channel_cb_s *channel = NULL; GSList *l; for (l = handle->channel_cb_list; l != NULL; l = l->next) { - channel_cb_s *tmp_channel = (channel_cb_s *)l->data; + mdg_channel_cb_s *tmp_channel = (mdg_channel_cb_s *)l->data; if (g_strcmp0(tmp_channel->channel_id, channel_id) == 0) channel = tmp_channel; } if (channel != NULL) - channel->cb(0, device_id, channel_id, msg_id, data, data_len, channel->user_data); - break; - } - case MDG_EVENT_SEND_FILE_PROGRESS: { - if (handle->send_file_cb.progress_cb) { - int percent = 0; - long long send_size, total_size; - char *file_path; - mdg_get_progress_from_variant(va, &file_path, &send_size, &total_size, &percent); - handle->send_file_cb.progress_cb(file_path, send_size, total_size, percent, - handle->send_file_cb.user_data); - } else { - _ERR("The callback not exists"); - } - break; - } - case MDG_EVENT_SEND_FILE_FINISH: { - if (handle->send_file_cb.finish_cb) { - mdg_device_s *device = (mdg_device_s *)(handle->send_file_cb.device); - handle->send_file_cb.finish_cb(ret, device, handle->send_file_cb.user_data); - } else { - _ERR("The callback not exists"); - } - break; - } - case MDG_EVENT_RECEIVE_FILE: { - if (handle->receive_file_cb.receive_cb) { - char *device_id; - char *file_path; - mdg_get_receive_file_from_variant(va, &device_id, &file_path); - handle->receive_file_cb.receive_cb(ret, device_id, file_path, - handle->receive_file_cb.user_data); - } else { - _ERR("The callback not exists"); - } + channel->receive_data_cb(0, device_id, channel_id, msg_id, data, data_len, channel->receive_data_cb_user_data); break; } case MDG_EVENT_INVITED: { @@ -216,6 +237,93 @@ static void __event_cb(Group *object, } break; } + case MDG_EVENT_RECEIVE_OPEN_CHANNEL: { + int ret = MDG_ERROR_NONE; + mdg_channel_cb_s *channel_cb = NULL; + mdg_channel_s *channel = calloc(1, sizeof(mdg_channel_s)); + if (NULL == channel) { + _ERR("Memory allocation failed"); + ret = MDG_ERROR_OUT_OF_MEMORY; + goto RECEIVE_OPEN_CHANNEL_EXIT; + } + + mdg_get_channel_from_variant(va, &channel->device_id, &channel->channel_id, + &channel->remote_address); + + GSList *l; + for (l = handle->channel_cb_list; l != NULL; l = l->next) { + mdg_channel_cb_s *tmp_channel = (mdg_channel_cb_s *)l->data; + if (g_strcmp0(tmp_channel->channel_id, channel->channel_id) == 0) + channel_cb = tmp_channel; + } + + if (channel_cb == NULL) { + _ERR("[%s] The channel is not registered", channel->channel_id); + ret = MDG_ERROR_NO_DATA; + goto RECEIVE_OPEN_CHANNEL_EXIT; + } + + socklen_t client_len; + char buf[128]; + + struct linger ling; + struct timeval tv_timeo = {3, 0}; + + ling.l_onoff = 1; + ling.l_linger = 0; + + struct sockaddr_in serveraddr, clientaddr; + char client_ipaddr[INET_ADDRSTRLEN]; + + channel->server_sockfd = socket(AF_INET, SOCK_STREAM, 0); + if (channel->server_sockfd == -1) { + ret = MDG_ERROR_OPERATION_FAILED; + strerror_r(errno, buf, 128); + _ERR("socket error : %s", buf); + goto RECEIVE_OPEN_CHANNEL_EXIT; + } + + setsockopt(channel->server_sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv_timeo, sizeof(tv_timeo)); + setsockopt(channel->server_sockfd, SOL_SOCKET, SO_LINGER, &ling, sizeof(ling)); + + serveraddr.sin_family = AF_INET; + serveraddr.sin_addr.s_addr = htonl(INADDR_ANY); + serveraddr.sin_port = htons(8675); + + if (bind(channel->server_sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0) { + ret = MDG_ERROR_OPERATION_FAILED; + strerror_r(errno, buf, 128); + _ERR("bind error : %s", buf); + goto RECEIVE_OPEN_CHANNEL_EXIT; + } + + if (listen(channel->server_sockfd, 5) != 0) { + ret = MDG_ERROR_OPERATION_FAILED; + strerror_r(errno, buf, 128); + _ERR("listen error : %s", buf); + goto RECEIVE_OPEN_CHANNEL_EXIT; + } + + client_len = sizeof(clientaddr); + channel->client_sockfd = accept(channel->server_sockfd, (struct sockaddr *)&clientaddr, &client_len); + inet_ntop(AF_INET, &clientaddr.sin_addr.s_addr, client_ipaddr, sizeof(client_ipaddr)); + _DBG("Accepted IP : %s, client socket : %d", client_ipaddr, channel->client_sockfd); + + if (channel->client_sockfd == -1) { + ret = MDG_ERROR_OPERATION_FAILED; + strerror_r(errno, buf, 128); + _ERR("socket error : %s", buf); + goto RECEIVE_OPEN_CHANNEL_EXIT; + } + +RECEIVE_OPEN_CHANNEL_EXIT: + if (channel_cb && channel_cb->opened_cb) { + channel_cb->opened_cb(ret, channel, channel_cb->opened_cb_user_data); + } else { + _ERR("The callback not exists"); + } + break; + } default: _ERR("Unknown Event"); break; diff --git a/src/mdg_gdbus.xml b/src/mdg_gdbus.xml index 966828b..e657f2f 100755 --- a/src/mdg_gdbus.xml +++ b/src/mdg_gdbus.xml @@ -102,6 +102,11 @@ + + + + + diff --git a/src/mdg_private.h b/src/mdg_private.h index 53f2e84..cb43781 100755 --- a/src/mdg_private.h +++ b/src/mdg_private.h @@ -121,22 +121,6 @@ typedef struct _send_data_finish_cb_t { } send_data_finish_cb_t; /** - * @brief Sending data to the device done callback structure - * @since_tizen 5.0 - */ -typedef struct _send_file_cb_t { - mdg_send_file_progress_cb progress_cb; /**< User callback to be called */ - mdg_send_file_finish_cb finish_cb; /**< User callback to be called */ - mdg_device_h device; - void *user_data; /**< User data pointer */ -} send_file_cb_t; - -typedef struct _receive_file_cb_t { - mdg_receive_file_cb receive_cb; /**< User callback to be called */ - void *user_data; /**< User data pointer */ -} receive_file_cb_t; - -/** * @brief Sending internal commands to the device done callback structure * @since_tizen 5.0 */ @@ -150,6 +134,12 @@ typedef struct _request_channel_list_finish_cb_t { void *user_data; /**< User data pointer */ } request_channel_list_finish_cb_t; +typedef struct _request_channel_open_finish_cb_t { + mdg_channel_opened_cb channel_opened_cb; /**< User callback to be called */ + mdg_device_h device; + void *user_data; /**< User data pointer */ +} request_channel_open_finish_cb_t; + typedef struct _invited_event_cb_t { mdg_invited_event_cb invited_event_cb; /**< User callback to be called */ void *user_data; /**< User data pointer */ @@ -177,10 +167,9 @@ typedef struct _mdg_manager_s { device_invite_finish_cb_t device_invite_finish_cb; /**< When it called after invinting a device done or timeout */ device_eject_finish_cb_t device_eject_finish_cb; /**< When it called after ejecting the device done or timeout */ send_data_finish_cb_t send_data_finish_cb; /**< When it called after sending the device done or timeout */ - send_file_cb_t send_file_cb; /**< When it called after sending the device done or timeout */ - receive_file_cb_t receive_file_cb; /**< When it called after sending the device done or timeout */ request_result_cb_t request_result_cb; /**< When it called after sending private commands or timeout */ request_channel_list_finish_cb_t request_channel_list_finish_cb; /**< When it called after sending private commands or timeout */ + request_channel_open_finish_cb_t request_channel_open_finish_cb; invited_event_cb_t invited_event_cb; ejected_event_cb_t ejected_event_cb; } mdg_manager_s; @@ -216,11 +205,23 @@ typedef struct _mdg_device_s { mdg_device_type_e type; /**< Device Type */ } mdg_device_s; -typedef struct _channel_cb_s { +typedef struct _mdg_channel_s { + char *device_id; /**< Device ID */ + char *channel_id; + char *remote_address; + int server_sockfd; + int client_sockfd; + int remote_port; + mdg_channel_type_e type; +} mdg_channel_s; + +typedef struct _mdg_channel_cb_s { char *channel_id; - mdg_receive_data_cb cb; - void *user_data; -} channel_cb_s; + mdg_channel_receive_data_cb receive_data_cb; + void *receive_data_cb_user_data; + mdg_channel_opened_cb opened_cb; + void *opened_cb_user_data; +} mdg_channel_cb_s; typedef enum { MDG_EVENT_GROUP_FOUND = 100, @@ -232,10 +233,9 @@ typedef enum { MDG_EVENT_REQUEST_FINISH, MDG_EVENT_SEND_DATA_FINISH, MDG_EVENT_REQ_CHANNEL_LIST_FINISH, - MDG_EVENT_RECEIVE_DATA, - MDG_EVENT_RECEIVE_FILE = 110, - MDG_EVENT_SEND_FILE_PROGRESS, - MDG_EVENT_SEND_FILE_FINISH, + MDG_EVENT_REQ_CHANNEL_OPEN_FINISH, + MDG_EVENT_RECEIVE_DATA = 110, + MDG_EVENT_RECEIVE_OPEN_CHANNEL } mdg_private_event_type_e; #endif /* __TIZEN_NETWORK_COMMON_MDG_PRIVATE_H__ */ diff --git a/src/mdg_util.c b/src/mdg_util.c index 3d602f6..37b0f13 100755 --- a/src/mdg_util.c +++ b/src/mdg_util.c @@ -112,7 +112,8 @@ mdg_device_s *mdg_get_device_from_variant(GVariant *va) return device; } -void mdg_get_channel_from_variant(GVariant *va, char **device_id, char **channel_id) +void mdg_get_channel_from_variant(GVariant *va, char **device_id, char **channel_id, + char **remote_address) { GVariantIter *iter = NULL; const gchar *key; @@ -124,6 +125,10 @@ void mdg_get_channel_from_variant(GVariant *va, char **device_id, char **channel *device_id = (char *)g_variant_get_string(key_value, NULL); else if (g_strcmp0(key, "ChannelID") == 0) *channel_id = (char *)g_variant_get_string(key_value, NULL); + else if (g_strcmp0(key, "RemoteAddress") == 0) { + if (remote_address != NULL) + *remote_address = (char *)g_variant_get_string(key_value, NULL); + } } g_variant_iter_free(iter); diff --git a/src/mdg_util.h b/src/mdg_util.h index c3dde47..47619d3 100755 --- a/src/mdg_util.h +++ b/src/mdg_util.h @@ -27,7 +27,8 @@ extern "C" { GVariant *mdg_create_variant_device(mdg_device_s *device); mdg_device_s *mdg_get_device_from_variant(GVariant *va); mdg_group_s *mdg_get_group_from_variant(GVariant *va); -void mdg_get_channel_from_variant(GVariant *va, char **device_id, char **channel_id); +void mdg_get_channel_from_variant(GVariant *va, char **device_id, char **channel_id, + char **remote_address); void mdg_get_data_from_variant(GVariant *va, char **device_id, char **channel_id, int *msg_id, unsigned char **data, int *data_len); void mdg_get_receive_file_from_variant(GVariant *va, char **device_id, char **file_path); diff --git a/test/mdg-manager.c b/test/mdg-manager.c old mode 100644 new mode 100755 index 2deaffd..cec9ac7 --- a/test/mdg-manager.c +++ b/test/mdg-manager.c @@ -42,7 +42,6 @@ static char channel_idx[MENU_DATA_SIZE + 1] = "1"; static char pin[MENU_DATA_SIZE + 1] = "12341234"; static char message[MENU_DATA_SIZE + 1] = "Hello World!!"; static char channel_id[MENU_DATA_SIZE + 1] = "Channel1"; -static char file_path[MENU_DATA_SIZE + 1] = "/path/to/file"; static int run_group_find(MManager *mm, struct menu_data *menu); static int run_devices_find(MManager *mm, struct menu_data *menu); @@ -595,11 +594,6 @@ void __ejected_event_cb(mdg_group_h group, void *user_data) g_free(name); } -void __receive_file_cb(int result, char *device_id, const char *file_path, void *user_data) -{ - msgb("The %s is stored by %s", file_path, device_id); -} - int run_device_show_local_device(MManager *mm, struct menu_data *menu) { int ret = 0; @@ -661,7 +655,6 @@ int run_device_show_local_device(MManager *mm, struct menu_data *menu) mdg_set_invited_event_cb(handle, __invited_event_cb, NULL); mdg_set_ejected_event_cb(handle, __ejected_event_cb, NULL); - mdg_set_receive_file_cb(handle, __receive_file_cb, NULL); return RET_SUCCESS; } @@ -899,72 +892,6 @@ static int run_send_data(MManager *mm, struct menu_data *menu) return __send_data(devidx, chaidx); } -void __send_file_progress_cb(const char *file_path, long long send_size, - long long total_size, int percent, void *user_data) -{ - msgp("%s %d%% [%lld/%lld]", file_path, percent, send_size, total_size); -} -void __send_file_finish_cb(int result, mdg_device_h device, void *user_data) -{ - char *device_id; - - mdg_device_info_get_device_id(device, &device_id); - - msgp("Send file to %s Finished [%s]", device_id, mdg_error_to_string(result)); - - g_free(device_id); -} - -static int __send_file(int devidx) -{ - int ret = 0; - char *deviceid = NULL; - mdg_device_h device = NULL; - - if (found_invited_device_list) { - device = g_list_nth_data(found_invited_device_list, devidx - 1); - if (NULL == device) { - msgr("Find local device first"); - return RET_FAILURE; - } - } - - mdg_device_info_get_device_id(device, &deviceid); - msgp("Sent to [ID] %s", deviceid); - if (deviceid) { - free(deviceid); - deviceid = NULL; - } - - ret = mdg_device_send_file(handle, device, file_path, - __send_file_progress_cb, __send_file_finish_cb, NULL); - if (MDG_ERROR_NONE != ret) - msgr("Failed to Send Data: [ID] %s", deviceid); - - return ret; -} - -static int run_send_file(MManager *mm, struct menu_data *menu) -{ - int devidx = 0; - int count = g_list_length(found_invited_device_list); - - if (0 >= count) { - msgr("No Device"); - return RET_SUCCESS; - } - - if (strlen(device_idx)) { - devidx = (unsigned short)strtol(device_idx, NULL, 10); - if (0 >= devidx) { - msgp("Invalid index. set to 1"); - devidx = 1; - } - } - - return __send_file(devidx); -} - void _invited_device_finish_cb(int result, void *user_data) { msgb("\rFind My Owned Devices Finished ret: [0x%X] [%s]", result, @@ -1252,14 +1179,30 @@ void __channel_cb(int result, char *device_id, char *channel_id, int msg_id, mdg_device_send_response(handle, device_id, channel_id, msg_id, (unsigned char *)"Ya, Hi", 6); } + +void __channel_opened_cb(int result, mdg_channel_h channel, void *user_data) +{ + msgb("result is %d", result); + if (result == MDG_ERROR_NONE) + msgb("channel opened callback is called. server socket is created"); + else + msgb("channel opened callback is called. but server socket is not created"); + + unsigned char buf[256] = "SENDSEND"; + mdg_channel_write(channel, buf, 256); + //write and recv using mdg_channel_write / mdg_channel_recv +} + static int run_regist_channel(MManager *mm, struct menu_data *menu) { int ret = 0; ret = mdg_device_regist_channel(handle, channel_id, __channel_cb, NULL); - msg(" - mdg_device_regist_channel() ret: [0x%X] [%s]", ret, mdg_error_to_string(ret)); + ret = mdg_set_channel_opened_callback(handle, channel_id, __channel_opened_cb, NULL); + msg(" - mdg_set_channel_opened_callback() ret: [0x%X] [%s]", ret, mdg_error_to_string(ret)); + return RET_SUCCESS; } @@ -1285,6 +1228,99 @@ static int run_set_preconfigured_pin(MManager *mm, struct menu_data *menu) return RET_SUCCESS; } +void _mdg_channel_client_opened_cb(int result, mdg_channel_h channel, void *user_data) +{ + msgp("Client Opened result : %d", result); + + unsigned char *buf; + buf = (unsigned char *)malloc(1024); + int len; + mdg_channel_read(channel, &buf, &len); + + msgp("Get Data : %s, %d", buf, len); +} + +static int __request_open_channel(int devidx, int chaidx) +{ + int ret = 0; + char *deviceid = NULL; + mdg_device_h device = NULL; + channel_t *channel = NULL; + + if (!found_invited_device_list || !found_channel_list) { + msgr("Find local device first"); + return RET_FAILURE; + } + + if (found_invited_device_list) { + device = g_list_nth_data(found_invited_device_list, devidx - 1); + if (NULL == device) { + msgr("Find local device first"); + return RET_FAILURE; + } + } + + if (found_channel_list) { + channel = g_list_nth_data(found_channel_list, chaidx - 1); + if (NULL == channel) { + msgr("Find local device first"); + return RET_FAILURE; + } + } + + if (NULL == device) { + msgr("device is NULL"); + return RET_FAILURE; + } + + if (NULL == channel) { + msgr("channel is NULL"); + return RET_FAILURE; + } + + mdg_device_info_get_device_id(device, &deviceid); + msgp("Open channel between [ID] %s [CHANNEL ID] %s", deviceid, channel->channel_id); + if (deviceid) { + free(deviceid); + deviceid = NULL; + } + + ret = mdg_request_channel_open(handle, device, channel->channel_id, + _mdg_channel_client_opened_cb, NULL); + if (MDG_ERROR_NONE != ret) + msgr("Failed to Send Data: [ID] %s", deviceid); + + return ret; +} + +static int run_request_open_channel(MManager *mm, struct menu_data *menu) +{ + int devidx = 0; + int chaidx = 0; + int count = g_list_length(found_invited_device_list); + + if (0 >= count) { + msgr("No Device"); + return RET_SUCCESS; + } + + if (strlen(device_idx)) { + devidx = (unsigned short)strtol(device_idx, NULL, 10); + if (0 >= devidx) { + msgp("Invalid index. set to 1"); + devidx = 1; + } + } + if (strlen(channel_idx)) { + chaidx = (unsigned short)strtol(channel_idx, NULL, 10); + if (0 >= chaidx) { + msgp("Invalid index. set to 1"); + chaidx = 1; + } + } + return __request_open_channel(devidx, chaidx); +} + static struct menu_data menu_group_create[] = { { "0", "Group Name", NULL, NULL, groupid }, { "1", "Run", NULL, run_group_create, NULL }, @@ -1346,14 +1382,6 @@ static struct menu_data menu_send_data[] = { { NULL, NULL, }, }; -static struct menu_data menu_send_file[] = { - { "0", "Show Found Invited Device(s)", NULL, run_invited_devices_show, NULL }, - { "1", "File Path", NULL, NULL, file_path }, - { "2", "Device Index", NULL, NULL, device_idx }, - { "3", "Send", NULL, run_send_file, NULL }, - { NULL, NULL, }, -}; - static struct menu_data menu_devices_find_invited_device[] = { { "0", "Timeout", NULL, NULL, timeout }, { "1", "Run", NULL, run_devices_find_invited_device, NULL }, @@ -1412,6 +1440,15 @@ static struct menu_data menu_set_preconfigured_pin[] = { { NULL, NULL, }, }; +static struct menu_data menu_request_open_channel[] = { + { "0", "Show Found Invited Device(s)", NULL, run_invited_devices_show, NULL }, + { "1", "Show Channel List", NULL, run_channels_show, NULL }, + { "2", "Device Index", NULL, NULL, device_idx }, + { "3", "Channel Index", NULL, NULL, channel_idx }, + { "4", "Run", NULL, run_request_open_channel, NULL }, + { NULL, NULL, }, +}; + struct menu_data menu_mdg_manager[] = { { "1", "Show Local Device", NULL, run_device_show_local_device, NULL }, // O { "2", "Create Group", menu_group_create, NULL, NULL }, // 0 @@ -1432,6 +1469,6 @@ struct menu_data menu_mdg_manager[] = { { "17", "Regist Channel", menu_regist_channel, NULL, NULL }, { "18", "Unregist Channel", menu_unregist_channel, NULL, NULL }, { "19", "Send Message", menu_send_data, NULL, NULL }, // 0 - { "20", "Send File", menu_send_file, NULL, NULL }, // 0 - { "21", "Set Preconfigured PIN", menu_set_preconfigured_pin, NULL, NULL }, // 0 + { "20", "Set Preconfigured PIN", menu_set_preconfigured_pin, NULL, NULL }, // 0 + { "21", "Request Open Channel", menu_request_open_channel, NULL, NULL }, // 0 }; -- 2.7.4 From 326412d9da8654782c30fa895a8e937e2b7cfef7 Mon Sep 17 00:00:00 2001 From: saerome kim Date: Fri, 10 May 2019 14:43:23 +0900 Subject: [PATCH 13/16] Fixed svace issues - 372991: fixed memory leak issue. - 372995: change a vulnerable function (strerror) to strerror_r. Change-Id: I2d5e6b815149b30afe0511b831c8d2325abb21b1 Signed-off-by: saerome kim --- src/mdg_dbus.c | 4 +++- test/mdg-manager.c | 6 ++++++ 2 files changed, 9 insertions(+), 1 deletion(-) mode change 100755 => 100644 src/mdg_dbus.c mode change 100755 => 100644 test/mdg-manager.c diff --git a/src/mdg_dbus.c b/src/mdg_dbus.c old mode 100755 new mode 100644 index f10dd00..5e439f0 --- a/src/mdg_dbus.c +++ b/src/mdg_dbus.c @@ -177,7 +177,9 @@ static void __event_cb(Group *object, ret = connect(channel->client_sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)); if (ret == -1) { - _DBG("Connect error : %s", strerror(errno)); + char buf[128]; + strerror_r(errno, buf, 128); + _DBG("Connect error : %s", buf); } else { _DBG("Success Connect to %s", ret_ptr); } diff --git a/test/mdg-manager.c b/test/mdg-manager.c old mode 100755 new mode 100644 index cec9ac7..35fca8f --- a/test/mdg-manager.c +++ b/test/mdg-manager.c @@ -1234,10 +1234,16 @@ void _mdg_channel_client_opened_cb(int result, mdg_channel_h channel, void *user unsigned char *buf; buf = (unsigned char *)malloc(1024); + if (NULL == buf) { + msgp("memory allocation error"); + return; + } int len; mdg_channel_read(channel, &buf, &len); msgp("Get Data : %s, %d", buf, len); + free(buf); + buf = NULL; } static int __request_open_channel(int devidx, int chaidx) -- 2.7.4 From 78fca4c1485f11b80ab771c5c19177fef47fb972 Mon Sep 17 00:00:00 2001 From: Jung Jihoon Date: Tue, 9 Jul 2019 13:19:02 +0900 Subject: [PATCH 14/16] make a gcov package for measuring coverage easier Change-Id: I548f4dd7fa6d2b1e81b9b17d803991902468f752 Signed-off-by: Jung Jihoon --- packaging/capi-network-mdg.spec | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/packaging/capi-network-mdg.spec b/packaging/capi-network-mdg.spec index b947c2d..8f96c2e 100644 --- a/packaging/capi-network-mdg.spec +++ b/packaging/capi-network-mdg.spec @@ -30,6 +30,15 @@ Requires: %{name} = %{version}-%{release} %description devel This package contains the development files for %{name} API library. +%if 0%{?gcov:1} +%package gcov +Summary: A MDG gcov Tool +Group: Network & Connectivity/Development + +%description gcov +MDG gcov objects +%endif + %prep %setup #-q chmod g-w %_sourcedir/* @@ -59,10 +68,22 @@ cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} \ -DDBDIR=%{DBDIR} \ -DBUILD_GCOV=%{?gcov:1}%{!?gcov:0} +make %{?jobs:-j%jobs} + +%if 0%{?gcov:1} +mkdir -p gcov-obj +find . -name '*.gcno' -exec cp '{}' gcov-obj ';' +%endif + %install rm -rf %{buildroot}/BUILD/%{name} %make_install +%if 0%{?gcov:1} +mkdir -p %{buildroot}%{_datadir}/gcov/obj +install -m 0644 gcov-obj/* %{buildroot}%{_datadir}/gcov/obj +%endif + %post -p /sbin/ldconfig %postun -p /sbin/ldconfig @@ -79,4 +100,9 @@ rm -rf %{buildroot}/BUILD/%{name} %attr(644,-,-) %{_libdir}/lib%{name}.so* %{_libdir}/pkgconfig/%{name}.pc %{_includedir}/*.h -%attr(777,network_fw,network_fw) %{_bindir}/mdg-test \ No newline at end of file +%attr(777,network_fw,network_fw) %{_bindir}/mdg-test + +%if 0%{?gcov:1} +%files gcov +%{_datadir}/gcov/obj/* +%endif -- 2.7.4 From c1a56c53bb0ac2bcf46054efac1f9d28de8efdf0 Mon Sep 17 00:00:00 2001 From: Jung Jihoon Date: Tue, 9 Jul 2019 21:24:30 +0900 Subject: [PATCH 15/16] Fix Coverity issues - Logically dead code: 1051469 - Dereference null return value : 1051467 - Unchecked return value : 1051464 - resource leak: 1051461 1043634 1043622 1043615 1043603 1043597 - no effect: 1043629 1043627 1043625 1043618 - Uninitialized scalar variable: 1043605 1051462 Change-Id: I558827611b721d92fbcbbc2811b5b9501a41ceed Signed-off-by: Jung Jihoon --- src/mdg.c | 70 +++------------------------------------------- src/mdg_dbus.c | 70 +++++++++++++++++++++++++++++++++++++--------- src/mdg_util.c | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/mdg_util.h | 3 ++ test/mdg-manager.c | 13 ++++++--- 5 files changed, 155 insertions(+), 83 deletions(-) mode change 100644 => 100755 src/mdg_dbus.c mode change 100644 => 100755 test/mdg-manager.c diff --git a/src/mdg.c b/src/mdg.c index 301d52f..52e8997 100755 --- a/src/mdg.c +++ b/src/mdg.c @@ -94,25 +94,6 @@ EXPORT_API int mdg_group_create(mdg_h handle, char *group_name) return ret; } -EXPORT_API void mdg_group_destroy(mdg_group_s *group) -{ - CHECK_FEATURE_SUPPORTED(MDG_FEATURE); - - mdg_check_null_ret("group", group); - - if (group->device_id) { - g_free(group->device_id); - group->device_id = NULL; - } - if (group->group_name) { - g_free(group->group_name); - group->group_name = NULL; - } - - g_free(group); - group = NULL; -} - EXPORT_API int mdg_group_find(mdg_h handle, int timeout, mdg_group_found_cb found_cb, mdg_group_find_finish_cb finish_cb, void *user_data) @@ -428,7 +409,7 @@ EXPORT_API int mdg_channel_read(mdg_channel_h channel, unsigned char **data, int mdg_check_null_ret_error("channel", channel, MDG_ERROR_INVALID_PARAMETER); *len = read(_channel->client_sockfd, *data, MAXBUF); - if (ret == -1) { + if (*len == -1) { char buf[128]; strerror_r(errno, buf, 128); _ERR("read() error : %s", buf); @@ -728,20 +709,9 @@ EXPORT_API int mdg_group_info_destroy(mdg_group_h data) CHECK_FEATURE_SUPPORTED(MDG_FEATURE); - mdg_group_s *group = (mdg_group_s *)data; - mdg_check_null_ret_error("group", group, MDG_ERROR_INVALID_PARAMETER); - - if (group->device_id) { - g_free(group->device_id); - group->device_id = NULL; - } - if (group->group_name) { - g_free(group->group_name); - group->group_name = NULL; - } + mdg_check_null_ret_error("data", data, MDG_ERROR_INVALID_PARAMETER); - g_free(group); - group = NULL; + mdg_clean_group((mdg_group_s *)data); return ret; } @@ -832,41 +802,9 @@ EXPORT_API int mdg_device_info_destroy(mdg_device_h data) CHECK_FEATURE_SUPPORTED(MDG_FEATURE); - mdg_device_s * device = (mdg_device_s *)data; mdg_check_null_ret_error("data", data, MDG_ERROR_INVALID_PARAMETER); - if (device->device_id) { - g_free(device->device_id); - device->device_id = NULL; - } - - if (device->model_name) { - g_free(device->model_name); - device->model_name = NULL; - } - - if (device->device_name) { - g_free(device->device_name); - device->device_name = NULL; - } - - if (device->platform_ver) { - g_free(device->platform_ver); - device->platform_ver = NULL; - } - - if (device->vendor_id) { - g_free(device->vendor_id); - device->vendor_id = NULL; - } - - if (device->profile) { - g_free(device->profile); - device->profile = NULL; - } - - g_free(device); - device = NULL; + mdg_clean_device((mdg_device_s *)data); return ret; } diff --git a/src/mdg_dbus.c b/src/mdg_dbus.c old mode 100644 new mode 100755 index 5e439f0..6b1ef91 --- a/src/mdg_dbus.c +++ b/src/mdg_dbus.c @@ -50,10 +50,13 @@ static void __event_cb(Group *object, case MDG_EVENT_GROUP_FOUND: { mdg_group_s *group = NULL; - group = mdg_get_group_from_variant(va); if (handle->group_found_cb.found_cb) { + group = mdg_get_group_from_variant(va); + handle->group_found_cb.found_cb(group->type, group, handle->group_found_cb.user_data); + + mdg_clean_group(group); } else { _ERR("The callback not exists"); } @@ -71,10 +74,13 @@ static void __event_cb(Group *object, case MDG_EVENT_DEVICE_FOUND: { mdg_device_s *device = NULL; - device = mdg_get_device_from_variant(va); if (handle->device_found_cb.found_cb) { + device = mdg_get_device_from_variant(va); + handle->device_found_cb.found_cb(device, handle->device_found_cb.user_data); + + mdg_clean_device(device); } else { _ERR("The callback not exists"); } @@ -97,6 +103,8 @@ static void __event_cb(Group *object, } handle->device_invite_finish_cb.finish_cb(ret, device, handle->device_invite_finish_cb.user_data); + + mdg_clean_device(device); } else { _ERR("The callback not exists"); } @@ -118,11 +126,15 @@ static void __event_cb(Group *object, unsigned char *data = NULL; int data_len = 0; - mdg_get_data_from_variant(va, &device_id, &channel_id, &msg_id, &data, &data_len); - mdg_device_s *device = (mdg_device_s *)(handle->send_data_finish_cb.device); if (handle->send_data_finish_cb.finish_cb) { + mdg_device_s *device = (mdg_device_s *)(handle->send_data_finish_cb.device); + mdg_get_data_from_variant(va, &device_id, &channel_id, &msg_id, &data, &data_len); + handle->send_data_finish_cb.finish_cb(ret, device, channel_id, msg_id, data, data_len, handle->send_data_finish_cb.user_data); + mdg_clean_device(device); + if (data != NULL) + free(data); } else { _ERR("The callback not exists"); } @@ -171,6 +183,12 @@ static void __event_cb(Group *object, sscanf(channel->remote_address, "coaps://%s", (char *)tempaddr); ret_ptr = strtok_r(tempaddr, ":", &temp_for_strtok); + if (ret_ptr == NULL) { + _ERR("strtok failed"); + ret = MDG_ERROR_OPERATION_FAILED; + goto REQUEST_OPEN_CHANNEL_FINISH_EXIT; + } + _ERR("Address is %s", ret_ptr); inet_pton(AF_INET, ret_ptr, &serveraddr.sin_addr.s_addr); @@ -191,6 +209,9 @@ REQUEST_OPEN_CHANNEL_FINISH_EXIT: } else { _ERR("The callback not exists"); } + + mdg_clean_channel(channel); + break; } case MDG_EVENT_RECEIVE_DATA: { @@ -198,7 +219,7 @@ REQUEST_OPEN_CHANNEL_FINISH_EXIT: char *channel_id; int msg_id; unsigned char *data; - int data_len; + int data_len = 0; mdg_get_data_from_variant(va, &device_id, &channel_id, &msg_id, &data, &data_len); @@ -213,15 +234,21 @@ REQUEST_OPEN_CHANNEL_FINISH_EXIT: if (channel != NULL) channel->receive_data_cb(0, device_id, channel_id, msg_id, data, data_len, channel->receive_data_cb_user_data); + + if (data != NULL) + free(data); + break; } case MDG_EVENT_INVITED: { mdg_group_s *group = NULL; - group = mdg_get_group_from_variant(va); - if (handle->invited_event_cb.invited_event_cb) { + group = mdg_get_group_from_variant(va); + handle->invited_event_cb.invited_event_cb(group, handle->invited_event_cb.user_data); + + mdg_clean_group(group); } else { _ERR("The callback not exists"); } @@ -230,10 +257,12 @@ REQUEST_OPEN_CHANNEL_FINISH_EXIT: case MDG_EVENT_EJECTED: { mdg_group_s *group = NULL; - group = mdg_get_group_from_variant(va); - if (handle->ejected_event_cb.ejected_event_cb) { + group = mdg_get_group_from_variant(va); + handle->ejected_event_cb.ejected_event_cb(group, handle->ejected_event_cb.user_data); + + mdg_clean_group(group); } else { _ERR("The callback not exists"); } @@ -285,12 +314,24 @@ REQUEST_OPEN_CHANNEL_FINISH_EXIT: goto RECEIVE_OPEN_CHANNEL_EXIT; } - setsockopt(channel->server_sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv_timeo, sizeof(tv_timeo)); - setsockopt(channel->server_sockfd, SOL_SOCKET, SO_LINGER, &ling, sizeof(ling)); + if (setsockopt(channel->server_sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv_timeo, sizeof(tv_timeo)) < 0) { + ret = MDG_ERROR_OPERATION_FAILED; + strerror_r(errno, buf, 128); + _ERR("setsockopt error : %s", buf); + goto RECEIVE_OPEN_CHANNEL_EXIT; + } + + if (setsockopt(channel->server_sockfd, SOL_SOCKET, SO_LINGER, &ling, sizeof(ling)) < 0) { + ret = MDG_ERROR_OPERATION_FAILED; + strerror_r(errno, buf, 128); + _ERR("setsockopt error : %s", buf); + goto RECEIVE_OPEN_CHANNEL_EXIT; + } serveraddr.sin_family = AF_INET; serveraddr.sin_addr.s_addr = htonl(INADDR_ANY); serveraddr.sin_port = htons(8675); + memset(&serveraddr.sin_zero, 0, sizeof(serveraddr.sin_zero)); if (bind(channel->server_sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0) { ret = MDG_ERROR_OPERATION_FAILED; @@ -324,6 +365,9 @@ RECEIVE_OPEN_CHANNEL_EXIT: } else { _ERR("The callback not exists"); } + + mdg_clean_channel(channel); + break; } default: @@ -385,9 +429,9 @@ static void _dbus_name_owner_notify(GObject *object, GParamSpec *pspec, gpointer *user_data) { GDBusProxy *proxy = G_DBUS_PROXY(object); - gchar *name_owner = g_dbus_proxy_get_name_owner(proxy); - mdg_manager_s *handle = (mdg_manager_s *)user_data; mdg_check_null_ret("user_data", user_data); + mdg_manager_s *handle = (mdg_manager_s *)user_data; + gchar *name_owner = g_dbus_proxy_get_name_owner(proxy); LOGD("Name owner notify [%s]", name_owner); diff --git a/src/mdg_util.c b/src/mdg_util.c index 37b0f13..900ef14 100755 --- a/src/mdg_util.c +++ b/src/mdg_util.c @@ -240,3 +240,85 @@ GVariant *mdg_create_variant_device(mdg_device_s *device) return va; } + +void mdg_clean_group (mdg_group_s *group) +{ + if (group == NULL) + return; + + if (group->device_id) { + g_free(group->device_id); + group->device_id = NULL; + } + if (group->group_name) { + g_free(group->group_name); + group->group_name = NULL; + } + + g_free(group); + group = NULL; +} + +void mdg_clean_device (mdg_device_s *device) +{ + if (device == NULL) + return; + + if (device->device_id) { + g_free(device->device_id); + device->device_id = NULL; + } + + if (device->model_name) { + g_free(device->model_name); + device->model_name = NULL; + } + + if (device->device_name) { + g_free(device->device_name); + device->device_name = NULL; + } + + if (device->platform_ver) { + g_free(device->platform_ver); + device->platform_ver = NULL; + } + + if (device->vendor_id) { + g_free(device->vendor_id); + device->vendor_id = NULL; + } + + if (device->profile) { + g_free(device->profile); + device->profile = NULL; + } + + g_free(device); + device = NULL; +} + +void mdg_clean_channel (mdg_channel_s *channel) +{ + if (channel == NULL) + return; + + if (channel->device_id) { + g_free(channel->device_id); + channel->device_id = NULL; + } + + if (channel->channel_id) { + g_free(channel->channel_id); + channel->channel_id = NULL; + } + + if (channel->remote_address) { + g_free(channel->remote_address); + channel->remote_address = NULL; + } + + g_free(channel); + channel = NULL; +} + diff --git a/src/mdg_util.h b/src/mdg_util.h index 47619d3..3efe801 100755 --- a/src/mdg_util.h +++ b/src/mdg_util.h @@ -34,6 +34,9 @@ void mdg_get_data_from_variant(GVariant *va, char **device_id, char **channel_id void mdg_get_receive_file_from_variant(GVariant *va, char **device_id, char **file_path); void mdg_get_progress_from_variant(GVariant *va, char **file_path, long long *send_size, long long *total_size, int *percent); +void mdg_clean_group (mdg_group_s *group); +void mdg_clean_device (mdg_device_s *device); +void mdg_clean_channel (mdg_channel_s *channel); #ifdef __cplusplus } diff --git a/test/mdg-manager.c b/test/mdg-manager.c old mode 100644 new mode 100755 index 35fca8f..9babdee --- a/test/mdg-manager.c +++ b/test/mdg-manager.c @@ -538,6 +538,8 @@ bool _device_found_cb(mdg_device_h device, void *user_data) if (device_id) free(device_id); + if (model_name) + free(model_name); return TRUE; } @@ -738,6 +740,9 @@ bool _group_found_cb(mdg_group_type_e type, mdg_group_h group, void *user_data) found_group_list = g_list_append(found_group_list, group); + if (group_name != NULL) + free(group_name); + return TRUE; } @@ -960,7 +965,7 @@ static int run_request_create_group(MManager *mm, struct menu_data *menu) } int dev_idx = 1; - if (device_idx != NULL && strlen(device_idx)) { + if (strlen(device_idx)) { dev_idx = (unsigned short)strtol(device_idx, NULL, 10); if (0 >= dev_idx) { msgp("Invalid index. set to 1"); @@ -1007,7 +1012,7 @@ static int run_request_invite(MManager *mm, struct menu_data *menu) } int grp_idx = 1; - if (group_idx != NULL && strlen(group_idx)) { + if (strlen(group_idx)) { grp_idx = (unsigned short)strtol(group_idx, NULL, 10); if (0 >= grp_idx) { msgp("Invalid index. set to 1"); @@ -1024,7 +1029,7 @@ static int run_request_invite(MManager *mm, struct menu_data *menu) } int dev_idx = 1; - if (device_idx != NULL && strlen(device_idx)) { + if (strlen(device_idx)) { dev_idx = (unsigned short)strtol(device_idx, NULL, 10); if (0 >= dev_idx) { msgp("Invalid index. set to 1"); @@ -1142,7 +1147,7 @@ static int run_request_channel_list(MManager *mm, struct menu_data *menu) } int dev_idx = 1; - if (device_idx != NULL && strlen(device_idx)) { + if (strlen(device_idx)) { dev_idx = (unsigned short)strtol(device_idx, NULL, 10); if (0 >= dev_idx) { msgp("Invalid index. set to 1"); -- 2.7.4 From 29d6e3ffc9b987ab06e920de288f634b78341c90 Mon Sep 17 00:00:00 2001 From: Jung Jihoon Date: Wed, 10 Jul 2019 16:52:39 +0900 Subject: [PATCH 16/16] Fix Side effect from "Fix Coverity issues" Change-Id: I67e9aade4eb955cd081dffad8ca996619684269f Signed-off-by: Jung Jihoon --- test/main.c | 3 +++ test/mdg-manager.c | 14 +++++++++++--- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/test/main.c b/test/main.c index 477af92..6714239 100644 --- a/test/main.c +++ b/test/main.c @@ -33,6 +33,7 @@ extern struct menu_data menu_mdg_manager[]; extern GList *found_group_list; extern GList *found_device_list; +extern GList *found_invited_device_list; extern mdg_h handle; #define CASE_TO_STR(x) case x: return #x; @@ -158,6 +159,8 @@ OUT: g_list_free_full(found_group_list, _free_group); if (found_device_list) g_list_free_full(found_device_list, _free_device); + if (found_invited_device_list) + g_list_free_full(found_invited_device_list, _free_device); mdg_deinitialize(handle); diff --git a/test/mdg-manager.c b/test/mdg-manager.c index 9babdee..8006911 100755 --- a/test/mdg-manager.c +++ b/test/mdg-manager.c @@ -531,7 +531,9 @@ bool _device_found_cb(mdg_device_h device, void *user_data) } if (is_exist == FALSE) { - found_device_list = g_list_append(found_device_list, device); + mdg_device_h cloned_device; + mdg_device_info_clone(&cloned_device, device); + found_device_list = g_list_append(found_device_list, cloned_device); msgp("\r[ID] %s [Type] %s [Name] %s", device_id, __device_type_to_string(device_type), model_name); } @@ -730,6 +732,7 @@ static void _destroy_mdg_group_info(gpointer data) bool _group_found_cb(mdg_group_type_e type, mdg_group_h group, void *user_data) { char *group_name; + mdg_group_h cloned_group; mdg_group_info_get_name(group, &group_name); @@ -738,7 +741,9 @@ bool _group_found_cb(mdg_group_type_e type, mdg_group_h group, void *user_data) else msgp("\rfound group type : REMOTE, name : %s", group_name); - found_group_list = g_list_append(found_group_list, group); + mdg_group_info_clone(&cloned_group, group); + + found_group_list = g_list_append(found_group_list, cloned_group); if (group_name != NULL) free(group_name); @@ -907,6 +912,7 @@ bool _invited_device_found_cb(mdg_device_h device, void *user_data) { char *device_id = NULL; mdg_device_type_e device_type; + mdg_device_h cloned_device; mdg_device_info_get_device_id(device, &device_id); mdg_device_info_get_type(device, &device_type); @@ -916,7 +922,9 @@ bool _invited_device_found_cb(mdg_device_h device, void *user_data) if (device_id) free(device_id); - found_invited_device_list = g_list_append(found_invited_device_list, device); + mdg_device_info_clone(&cloned_device, device); + + found_invited_device_list = g_list_append(found_invited_device_list, cloned_device); return TRUE; } -- 2.7.4