*/
int stc_pcap_foreach(stc_h stc, stc_pcap_info_cb callback, void *user_data);
+/**
+ * @brief Finds all devices.
+ * @since_tizen 5.0
+ *
+ * @param[in] stc The stc handle
+ * @param[in] callback The callback to be called
+ * @param[in] user_data The user data passed to the callback function
+ *
+ * @return 0 on success, otherwise a negative error value
+ * @retval #STC_ERROR_NONE Successful
+ * @retval #STC_ERROR_OPERATION_FAILED General error
+ * @retval #STC_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #STC_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STC_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #STC_ERROR_NOT_INITIALIZED Not initialized
+ * @retval #STC_ERROR_NOT_SUPPORTED Not supported
+ * @retval #STC_ERROR_PERMISSION_DENIED Permission denied
+ *
+ * @see #stc_pcap_h
+ * @see stc_pcap_create()
+ * @see stc_pcap_destroy()
+ */
+int stc_pcap_find_all_devs(stc_h stc, stc_pcap_info_cb callback, void *user_data);
+
/**
* @brief Sets interface name to pcap.
* @since_tizen 5.0
*/
int stc_pcap_get_nflog_group(stc_pcap_h pcap_h, int *group);
+/**
+ * @brief Gets name of device.
+ * @since_tizen 5.0
+ *
+ * @param[in] pcap_h The pcap handle
+ * @param[out] name The name of device
+ *
+ * @return 0 on success, otherwise a negative error value
+ * @retval #STC_ERROR_NONE Successful
+ * @retval #STC_ERROR_OPERATION_FAILED General error
+ * @retval #STC_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #STC_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STC_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #STC_ERROR_NOT_INITIALIZED Not initialized
+ * @retval #STC_ERROR_NOT_SUPPORTED Not supported
+ * @retval #STC_ERROR_PERMISSION_DENIED Permission denied
+ *
+ * @see #stc_pcap_h
+ * @see stc_pcap_create()
+ * @see stc_pcap_destroy()
+ */
+int stc_pcap_get_dev_name(stc_pcap_h pcap_h, char **name);
+
+/**
+ * @brief Gets description of device.
+ * @since_tizen 5.0
+ *
+ * @param[in] pcap_h The pcap handle
+ * @param[out] decs The description of device
+ *
+ * @return 0 on success, otherwise a negative error value
+ * @retval #STC_ERROR_NONE Successful
+ * @retval #STC_ERROR_OPERATION_FAILED General error
+ * @retval #STC_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #STC_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STC_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #STC_ERROR_NOT_INITIALIZED Not initialized
+ * @retval #STC_ERROR_NOT_SUPPORTED Not supported
+ * @retval #STC_ERROR_PERMISSION_DENIED Permission denied
+ *
+ * @see #stc_pcap_h
+ * @see stc_pcap_create()
+ * @see stc_pcap_destroy()
+ */
+int stc_pcap_get_dev_decs(stc_pcap_h pcap_h, char **decs);
+
+/**
+ * @brief Gets net of device.
+ * @since_tizen 5.0
+ *
+ * @param[in] pcap_h The pcap handle
+ * @param[out] net The net of device
+ *
+ * @return 0 on success, otherwise a negative error value
+ * @retval #STC_ERROR_NONE Successful
+ * @retval #STC_ERROR_OPERATION_FAILED General error
+ * @retval #STC_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #STC_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STC_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #STC_ERROR_NOT_INITIALIZED Not initialized
+ * @retval #STC_ERROR_NOT_SUPPORTED Not supported
+ * @retval #STC_ERROR_PERMISSION_DENIED Permission denied
+ *
+ * @see #stc_pcap_h
+ * @see stc_pcap_create()
+ * @see stc_pcap_destroy()
+ */
+int stc_pcap_get_dev_net(stc_pcap_h pcap_h, char **net);
+
+/**
+ * @brief Gets mask of device.
+ * @since_tizen 5.0
+ *
+ * @param[in] pcap_h The pcap handle
+ * @param[out] mask The mask of device
+ *
+ * @return 0 on success, otherwise a negative error value
+ * @retval #STC_ERROR_NONE Successful
+ * @retval #STC_ERROR_OPERATION_FAILED General error
+ * @retval #STC_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #STC_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STC_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #STC_ERROR_NOT_INITIALIZED Not initialized
+ * @retval #STC_ERROR_NOT_SUPPORTED Not supported
+ * @retval #STC_ERROR_PERMISSION_DENIED Permission denied
+ *
+ * @see #stc_pcap_h
+ * @see stc_pcap_create()
+ * @see stc_pcap_destroy()
+ */
+int stc_pcap_get_dev_mask(stc_pcap_h pcap_h, char **mask);
+
/**
* @}
*/
*****************************************************************************/
#include "stc.h"
+#include "stc-event.h"
#include "stc-private.h"
#include "stc-dbus.h"
stc_pcap_s *pcap = (stc_pcap_s *)data;
FREE(pcap->ifname);
+
+ FREE(pcap->dev_name);
+ FREE(pcap->dev_decs);
+ FREE(pcap->dev_net);
+ FREE(pcap->dev_mask);
+
FREE(pcap);
}
+static void __stc_pcap_print(stc_pcap_s *pcap)
+{
+ if (pcap == NULL)
+ return;
+
+ STC_LOGD(STC_HR_SINGLE);
+
+ STC_LOGD("[%s][%d]", pcap->ifname, pcap->nflog_group);
+
+ STC_LOGD(STC_HR_SINGLE);
+}
+
+static void __stc_pcap_dev_print(stc_pcap_s *pcap)
+{
+ if (pcap == NULL)
+ return;
+
+ STC_LOGD(STC_HR_SINGLE);
+
+ STC_LOGD("[%s][%s][%s][%s]", pcap->dev_name,
+ pcap->dev_decs, pcap->dev_net, pcap->dev_mask);
+
+ STC_LOGD(STC_HR_SINGLE);
+}
+
static void __stc_pcap_add_to_list(stc_pcap_h pcap_h)
{
g_pcap_list = g_slist_append(g_pcap_list, pcap_h);
g_variant_builder_unref(builder);
}
-static void __stc_pcap_print(stc_pcap_s *pcap)
+static void __stc_pcap_extract(const char *key,
+ GVariant *value, void *user_data)
{
+ stc_pcap_s *pcap = (stc_pcap_s *)user_data;
+
if (pcap == NULL)
return;
- STC_LOGD(STC_HR_SINGLE);
+ if (!g_strcmp0(key, STC_PCAP_IFNAME)) {
+ guint str_length;
+ const gchar *str = g_variant_get_string(value, &str_length);
+ pcap->ifname = g_strdup(str);
- STC_LOGD("[%s][%d]", pcap->ifname, pcap->nflog_group);
+ } else if (!g_strcmp0(key, STC_PCAP_NFLOG_GROUP)) {
+ pcap->nflog_group = g_variant_get_uint32(value);
- STC_LOGD(STC_HR_SINGLE);
+ }
+}
+
+static void __stc_pcap_dev_extract(const char *key,
+ GVariant *value, void *user_data)
+{
+ stc_pcap_s *pcap = (stc_pcap_s *)user_data;
+
+ if (pcap == NULL)
+ return;
+
+ if (!g_strcmp0(key, STC_PCAP_DEV_NAME)) {
+ guint str_length;
+ const gchar *str = g_variant_get_string(value, &str_length);
+ pcap->dev_name = g_strdup(str);
+
+ } else if (!g_strcmp0(key, STC_PCAP_DEV_DECS)) {
+ guint str_length;
+ const gchar *str = g_variant_get_string(value, &str_length);
+ pcap->dev_decs = g_strdup(str);
+
+ } else if (!g_strcmp0(key, STC_PCAP_DEV_NET)) {
+ guint str_length;
+ const gchar *str = g_variant_get_string(value, &str_length);
+ pcap->dev_net = g_strdup(str);
+
+ } else if (!g_strcmp0(key, STC_PCAP_DEV_MASK)) {
+ guint str_length;
+ const gchar *str = g_variant_get_string(value, &str_length);
+ pcap->dev_mask = g_strdup(str);
+
+ }
+}
+
+static void __stc_pcap_find_all_devs_reply(
+ GObject *source_object, GAsyncResult *res, gpointer user_data)
+{
+ GDBusConnection *conn = NULL;
+ GError *dbus_error = NULL;
+ GVariant *dbus_data = NULL;
+ GVariantIter *iter = NULL;
+ GVariantIter *iter_row = NULL;
+ stc_error_e error = STC_ERROR_NONE;
+ GSList *dev_list = NULL;
+ stc_event_info_s event_data = { 0, };
+
+ conn = G_DBUS_CONNECTION(source_object);
+ dbus_data = g_dbus_connection_call_finish(conn, res, &dbus_error);
+ if (dbus_error != NULL) {
+ error = _stc_convert_error_string_to_enum(dbus_error->message); //LCOV_EXCL_LINE
+ g_error_free(dbus_error); //LCOV_EXCL_LINE
+ }
+
+ if (_stc_event_get_request_table_state(STC_REQUEST_TABLE_PCAP_FIND_ALL_DEVS))
+ _stc_event_set_request_table_state(STC_REQUEST_TABLE_PCAP_FIND_ALL_DEVS, false);
+
+ if (error == STC_ERROR_NONE) {
+ g_variant_get(dbus_data, "(aa{sv})", &iter);
+
+ while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
+ stc_pcap_s *pcap = MALLOC0(stc_pcap_s, 1);
+ if (pcap != NULL) {
+ _stc_dbus_dictionary_foreach(iter_row,
+ __stc_pcap_dev_extract, pcap);
+
+ __stc_pcap_dev_print(pcap);
+
+ dev_list = g_slist_append(dev_list, (stc_pcap_s *)pcap);
+
+ g_variant_iter_free(iter_row);
+ }
+ }
+ g_variant_iter_free(iter);
+
+ event_data.event = STC_EVENT_PCAP_FIND_ALL_DEVS_RSP;
+ event_data.info_data = (GSList *)dev_list;
+ event_data.datalength = g_slist_length(dev_list);
+ event_data.error = STC_ERROR_NONE;
+ } else {
+ //LCOV_EXCL_START
+ STC_LOGE("Find all devs response error [%s]",
+ _stc_convert_error_type_to_string(error));
+
+ event_data.event = STC_EVENT_PCAP_FIND_ALL_DEVS_RSP;
+ event_data.info_data = NULL;
+ event_data.datalength = 0;
+ event_data.error = error;
+ //LCOV_EXCL_STOP
+ }
+
+ _stc_event_add_client_idle_cb(&event_data, user_data);
}
stc_error_e _stc_pcap_start(stc_pcap_s *pcap)
return STC_ERROR_NONE;
}
+stc_error_e _stc_pcap_foreach(stc_pcap_info_cb callback,
+ void *user_data)
+{
+ GVariant *message = NULL;
+ stc_error_e error = STC_ERROR_NONE;
+ GVariantIter *iter = NULL;
+ GVariantIter *iter_row = NULL;
+ GSList *pcap_list = NULL;
+ GSList *list = NULL;
+ stc_callback_ret_e rv = STC_CALLBACK_CANCEL;
+
+ message = _stc_dbus_invoke_method(
+ STC_MANAGER_SERVICE,
+ STC_MANAGER_PCAP_PATH,
+ STC_MANAGER_PCAP_INTERFACE,
+ STC_MANAGER_PCAP_METHOD_GETALL,
+ NULL,
+ &error);
+
+ STC_RETURN_VAL_IF(message == NULL,
+ error, "Failed to invoke dbus method");
+
+ g_variant_get(message, "(aa{sv})", &iter);
+
+ while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
+ stc_pcap_s *pcap = MALLOC0(stc_pcap_s, 1);
+
+ _stc_dbus_dictionary_foreach(iter_row,
+ __stc_pcap_extract, pcap);
+
+ __stc_pcap_print(pcap);
+
+ pcap_list = g_slist_append(pcap_list, (stc_pcap_s *)pcap);
+
+ g_variant_iter_free(iter_row);
+ }
+
+ g_variant_iter_free(iter);
+ g_variant_unref(message);
+
+ if ((int)g_slist_length(pcap_list) == 0) {
+ STC_LOGD("There are no pcap loop");
+ return STC_ERROR_NONE;
+ }
+
+ for (list = pcap_list; list; list = list->next) {
+ stc_pcap_s *pcap = (stc_pcap_s *)list->data;
+ __stc_pcap_add_to_list((stc_pcap_h)pcap);
+ rv = callback((stc_pcap_h)pcap, user_data);
+ __stc_pcap_remove_from_list((stc_pcap_h)pcap);
+ if (rv == false)
+ break;
+ }
+
+ g_slist_free_full(pcap_list, __stc_pcap_deinit);
+
+ return STC_ERROR_NONE;
+}
+
+stc_error_e _stc_pcap_find_all_devs(stc_pcap_info_cb callback,
+ void *user_data)
+{
+ stc_error_e error = STC_ERROR_NONE;
+
+ STC_RETURN_VAL_IF(
+ _stc_event_get_request_table_state(
+ STC_REQUEST_TABLE_PCAP_FIND_ALL_DEVS),
+ STC_ERROR_IN_PROGRESS,
+ "Request in progress");
+
+ _stc_event_set_request_table_state(
+ STC_REQUEST_TABLE_PCAP_FIND_ALL_DEVS, true);
+
+ error = _stc_dbus_invoke_method_nonblock(
+ STC_MANAGER_SERVICE,
+ STC_MANAGER_PCAP_PATH,
+ STC_MANAGER_PCAP_INTERFACE,
+ STC_MANAGER_PCAP_METHOD_FINDALLDEVS,
+ NULL,
+ STC_DBUS_REPLY_TIMEOUT,
+ __stc_pcap_find_all_devs_reply,
+ NULL);
+
+ if (error != STC_ERROR_NONE) {
+ STC_LOGE("Failed to invoke dbus method nonblock"); //LCOV_EXCL_LINE
+
+ _stc_event_set_request_table_state( //LCOV_EXCL_LINE
+ STC_REQUEST_TABLE_PCAP_FIND_ALL_DEVS, false);
+ return error; //LCOV_EXCL_LINE
+ }
+
+ return STC_ERROR_NONE;
+}
+
+void _stc_pcap_set_callback(stc_h stc,
+ stc_pcap_info_cb user_cb, void *user_data)
+{
+ stc_handle_s *handle = (stc_handle_s *)stc;
+
+ handle->pcap_info_cb = user_cb;
+ handle->pcap_info_user_data = user_data;
+}
+
EXPORT_API int stc_pcap_create(stc_h stc, stc_pcap_h *pcap_h)
{
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC);
return STC_ERROR_NONE;
}
-static void __stc_pcap_extract(const char *key,
- GVariant *value, void *user_data)
-{
- stc_pcap_s *pcap = (stc_pcap_s *)user_data;
-
- if (pcap == NULL)
- return;
-
- if (!g_strcmp0(key, STC_PCAP_IFNAME)) {
- guint str_length;
- const gchar *str = g_variant_get_string(value, &str_length);
- pcap->ifname = g_strdup(str);
-
- } else if (!g_strcmp0(key, STC_PCAP_NFLOG_GROUP)) {
- pcap->nflog_group = g_variant_get_uint32(value);
-
- }
-}
-
-stc_error_e _stc_pcap_foreach(stc_pcap_info_cb callback,
- void *user_data)
+EXPORT_API int stc_pcap_foreach(stc_h stc,
+ stc_pcap_info_cb callback, void *user_data)
{
- GVariant *message = NULL;
- stc_error_e error = STC_ERROR_NONE;
- GVariantIter *iter = NULL;
- GVariantIter *iter_row = NULL;
- GSList *pcap_list = NULL;
- GSList *list = NULL;
- stc_callback_ret_e rv = STC_CALLBACK_CANCEL;
-
- message = _stc_dbus_invoke_method(
- STC_MANAGER_SERVICE,
- STC_MANAGER_PCAP_PATH,
- STC_MANAGER_PCAP_INTERFACE,
- STC_MANAGER_PCAP_METHOD_GETALL,
- NULL,
- &error);
-
- STC_RETURN_VAL_IF(message == NULL,
- error, "Failed to invoke dbus method");
-
- g_variant_get(message, "(aa{sv})", &iter);
-
- while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
- stc_pcap_s *pcap = MALLOC0(stc_pcap_s, 1);
-
- _stc_dbus_dictionary_foreach(iter_row,
- __stc_pcap_extract, pcap);
-
- __stc_pcap_print(pcap);
+ int ret = STC_ERROR_NONE;
- pcap_list = g_slist_append(pcap_list, (stc_pcap_s *)pcap);
+ CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC);
- g_variant_iter_free(iter_row);
+ if (!(_stc_handle_check_validity(stc))) {
+ STC_LOGE("Invalid parameter");
+ return STC_ERROR_INVALID_PARAMETER;
}
- g_variant_iter_free(iter);
- g_variant_unref(message);
-
- if ((int)g_slist_length(pcap_list) == 0) {
- STC_LOGD("There are no pcap loop");
- return STC_ERROR_NONE;
+ if (callback == NULL) {
+ STC_LOGE("Invalid parameter");
+ return STC_ERROR_INVALID_PARAMETER;
}
- for (list = pcap_list; list; list = list->next) {
- stc_pcap_s *pcap = (stc_pcap_s *)list->data;
- __stc_pcap_add_to_list((stc_pcap_h)pcap);
- rv = callback((stc_pcap_h)pcap, user_data);
- __stc_pcap_remove_from_list((stc_pcap_h)pcap);
- if (rv == false)
- break;
+ ret = _stc_pcap_foreach(callback, user_data);
+ if (ret != STC_ERROR_NONE) {
+ STC_LOGE("Failed to get all pcap [%s]",
+ _stc_convert_error_type_to_string(ret));
+ return ret;
}
- g_slist_free_full(pcap_list, __stc_pcap_deinit);
-
return STC_ERROR_NONE;
}
-EXPORT_API int stc_pcap_foreach(stc_h stc,
+EXPORT_API int stc_pcap_find_all_devs(stc_h stc,
stc_pcap_info_cb callback, void *user_data)
{
int ret = STC_ERROR_NONE;
return STC_ERROR_INVALID_PARAMETER;
}
- ret = _stc_pcap_foreach(callback, user_data);
+ _stc_pcap_set_callback(stc, callback, user_data);
+
+ ret = _stc_pcap_find_all_devs(callback, user_data);
if (ret != STC_ERROR_NONE) {
- STC_LOGE("Failed to get all pcap [%s]",
+ STC_LOGE("Failed to find all devs [%s]",
_stc_convert_error_type_to_string(ret));
return ret;
}
return STC_ERROR_NONE;
}
+
+EXPORT_API int stc_pcap_get_dev_name(stc_pcap_h pcap_h, char **name)
+{
+ CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC);
+
+ if (!name) {
+ STC_LOGE("Invalid parameter");
+ return STC_ERROR_INVALID_PARAMETER;
+ }
+
+ stc_pcap_s *pcap = (stc_pcap_s *)pcap_h;
+
+ *name = g_strdup(pcap->dev_name);
+
+ STC_LOGI("Device name [%s]", *name);
+
+ return STC_ERROR_NONE;
+}
+
+EXPORT_API int stc_pcap_get_dev_decs(stc_pcap_h pcap_h, char **decs)
+{
+ CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC);
+
+ if (!decs) {
+ STC_LOGE("Invalid parameter");
+ return STC_ERROR_INVALID_PARAMETER;
+ }
+
+ stc_pcap_s *pcap = (stc_pcap_s *)pcap_h;
+
+ *decs = g_strdup(pcap->dev_decs);
+
+ STC_LOGI("Device description [%s]", *decs);
+
+ return STC_ERROR_NONE;
+}
+
+EXPORT_API int stc_pcap_get_dev_net(stc_pcap_h pcap_h, char **net)
+{
+ CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC);
+
+ if (!net) {
+ STC_LOGE("Invalid parameter");
+ return STC_ERROR_INVALID_PARAMETER;
+ }
+
+ stc_pcap_s *pcap = (stc_pcap_s *)pcap_h;
+
+ *net = g_strdup(pcap->dev_net);
+
+ STC_LOGI("Device net [%s]", *net);
+
+ return STC_ERROR_NONE;
+}
+
+EXPORT_API int stc_pcap_get_dev_mask(stc_pcap_h pcap_h, char **mask)
+{
+ CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC);
+
+ if (!mask) {
+ STC_LOGE("Invalid parameter");
+ return STC_ERROR_INVALID_PARAMETER;
+ }
+
+ stc_pcap_s *pcap = (stc_pcap_s *)pcap_h;
+
+ *mask = g_strdup(pcap->dev_mask);
+
+ STC_LOGI("Device mask [%s]", *mask);
+
+ return STC_ERROR_NONE;
+}
//LCOV_EXCL_STOP
projects / platform / core / api / smart-traffic-control.git / commitdiff