X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fconnection.c;h=bde33598cbbddc94c7e60ea42d47378769d96de5;hb=3b04e6c4e6b4a4b01a705f4396d3483de1d3eb56;hp=9622656f068423e64289d109acb129cc2b05c3cd;hpb=4d372ba939b7cdfcd1d5f351df10a95fede33463;p=platform%2Fcore%2Fapi%2Fconnection.git diff --git a/src/connection.c b/src/connection.c old mode 100644 new mode 100755 index 9622656..bde3359 --- a/src/connection.c +++ b/src/connection.c @@ -14,18 +14,19 @@ * limitations under the License. */ +#include #include +#include #include -#include #include +#include + #include "net_connection_private.h" static GSList *conn_handle_list = NULL; +static int tv_profile = -1; // Unknown -static void __connection_cb_state_change_cb(keynode_t *node, void *user_data); -static void __connection_cb_ip_change_cb(keynode_t *node, void *user_data); -static void __connection_cb_proxy_change_cb(keynode_t *node, void *user_data); - +//LCOV_EXCL_START static int __connection_convert_net_state(int status) { switch (status) { @@ -37,6 +38,8 @@ static int __connection_convert_net_state(int status) return CONNECTION_TYPE_ETHERNET; case VCONFKEY_NETWORK_BLUETOOTH: return CONNECTION_TYPE_BT; + case VCONFKEY_NETWORK_DEFAULT_PROXY: + return CONNECTION_TYPE_NET_PROXY; default: return CONNECTION_TYPE_DISCONNECTED; } @@ -58,261 +61,194 @@ static int __connection_convert_cellular_state(int status) } } -static int __connection_get_type_changed_callback_count(void) +static bool __connection_check_handle_validity(connection_h connection) { - GSList *list; - int count = 0; + bool ret = false; - for (list = conn_handle_list; list; list = list->next) { - connection_handle_s *local_handle = (connection_handle_s *)list->data; - if (local_handle->type_changed_callback) count++; - } + if (connection == NULL) + return false; - return count; -} + if (g_slist_find(conn_handle_list, connection) != NULL) + ret = true; -static int __connection_get_ip_changed_callback_count(void) -{ - GSList *list; - int count = 0; - - for (list = conn_handle_list; list; list = list->next) { - connection_handle_s *local_handle = (connection_handle_s *)list->data; - if (local_handle->ip_changed_callback) count++; - } - - return count; + return ret; } -static int __connection_get_proxy_changed_callback_count(void) +bool _connection_check_handle_validity(connection_h connection) { - GSList *list; - int count = 0; - - for (list = conn_handle_list; list; list = list->next) { - connection_handle_s *local_handle = (connection_handle_s *)list->data; - if (local_handle->proxy_changed_callback) count++; - } - - return count; + return __connection_check_handle_validity(connection); } -static int __connection_set_type_changed_callback(connection_h connection, - void *callback, void *user_data) +static int __connection_set_type_changed_callback(connection_handle_s *conn_handle, + void *callback, void *user_data) { - connection_handle_s *local_handle = (connection_handle_s *)connection; - - if (callback) { - if (__connection_get_type_changed_callback_count() == 0) - if (vconf_notify_key_changed(VCONFKEY_NETWORK_STATUS , - __connection_cb_state_change_cb, NULL)) - return CONNECTION_ERROR_OPERATION_FAILED; - - local_handle->state_changed_user_data = user_data; - } else { - if (local_handle->type_changed_callback && - __connection_get_type_changed_callback_count() == 1) - if (vconf_ignore_key_changed(VCONFKEY_NETWORK_STATUS, - __connection_cb_state_change_cb)) - return CONNECTION_ERROR_OPERATION_FAILED; - } + conn_handle->type_changed_user_data = user_data; + conn_handle->type_changed_callback = callback; - local_handle->type_changed_callback = callback; return CONNECTION_ERROR_NONE; } -static int __connection_set_ip_changed_callback(connection_h connection, - void *callback, void *user_data) +static int __connection_set_ip_changed_callback(connection_handle_s *conn_handle, + void *callback, void *user_data) { - connection_handle_s *local_handle = (connection_handle_s *)connection; + conn_handle->ip_changed_user_data = user_data; + conn_handle->ip_changed_callback = callback; - if (callback) { - if (__connection_get_ip_changed_callback_count() == 0) - if (vconf_notify_key_changed(VCONFKEY_NETWORK_IP, - __connection_cb_ip_change_cb, NULL)) - return CONNECTION_ERROR_OPERATION_FAILED; - - local_handle->ip_changed_user_data = user_data; - } else { - if (local_handle->ip_changed_callback && - __connection_get_ip_changed_callback_count() == 1) - if (vconf_ignore_key_changed(VCONFKEY_NETWORK_IP, - __connection_cb_ip_change_cb)) - return CONNECTION_ERROR_OPERATION_FAILED; - } - - local_handle->ip_changed_callback = callback; return CONNECTION_ERROR_NONE; } -static int __connection_set_proxy_changed_callback(connection_h connection, - void *callback, void *user_data) +static int __connection_set_proxy_changed_callback(connection_handle_s *conn_handle, + void *callback, void *user_data) { - connection_handle_s *local_handle = (connection_handle_s *)connection; - - if (callback) { - if (__connection_get_proxy_changed_callback_count() == 0) - if (vconf_notify_key_changed(VCONFKEY_NETWORK_PROXY, - __connection_cb_proxy_change_cb, NULL)) - return CONNECTION_ERROR_OPERATION_FAILED; + conn_handle->proxy_changed_user_data = user_data; + conn_handle->proxy_changed_callback = callback; - local_handle->proxy_changed_user_data = user_data; - } else { - if (local_handle->proxy_changed_callback && - __connection_get_proxy_changed_callback_count() == 1) - if (vconf_ignore_key_changed(VCONFKEY_NETWORK_PROXY, - __connection_cb_proxy_change_cb)) - return CONNECTION_ERROR_OPERATION_FAILED; - } - - local_handle->proxy_changed_callback = callback; return CONNECTION_ERROR_NONE; } -static void __connection_cb_state_change_cb(keynode_t *node, void *user_data) +static int __connection_set_ethernet_cable_state_changed_cb(connection_handle_s *conn_handle, + void *callback, void *user_data) { - CONNECTION_LOG(CONNECTION_INFO, "Net Status Changed Indication\n"); + conn_handle->ethernet_cable_state_changed_callback = callback; + conn_handle->ethernet_cable_state_changed_user_data = user_data; - GSList *list; - int state = vconf_keynode_get_int(node); - - for (list = conn_handle_list; list; list = list->next) { - connection_handle_s *local_handle = (connection_handle_s *)list->data; - if (local_handle->type_changed_callback) - local_handle->type_changed_callback( - __connection_convert_net_state(state), - local_handle->state_changed_user_data); - } + return CONNECTION_ERROR_NONE; } -static void __connection_cb_ip_change_cb(keynode_t *node, void *user_data) +static int __connection_set_default_cellular_service_profile_callback(connection_handle_s *conn_handle, + void *callback, void *user_data) { - CONNECTION_LOG(CONNECTION_INFO, "Net IP Changed Indication\n"); + conn_handle->set_default_callback = callback; + conn_handle->set_default_user_data = user_data; - GSList *list; - char *ip_addr = vconf_keynode_get_str(node); - - for (list = conn_handle_list; list; list = list->next) { - connection_handle_s *local_handle = (connection_handle_s *)list->data; - if (local_handle->ip_changed_callback) - local_handle->ip_changed_callback( - ip_addr, NULL, - local_handle->ip_changed_user_data); - } + return CONNECTION_ERROR_NONE; } -static void __connection_cb_proxy_change_cb(keynode_t *node, void *user_data) +static int __connection_open_profile_set_callback(connection_handle_s *conn_handle, + void *callback, void *user_data) { - CONNECTION_LOG(CONNECTION_INFO, "Net IP Changed Indication\n"); + conn_handle->opened_callback = callback; + conn_handle->opened_user_data = user_data; - GSList *list; - char *proxy = vconf_keynode_get_str(node); - - for (list = conn_handle_list; list; list = list->next) { - connection_handle_s *local_handle = (connection_handle_s *)list->data; - if (local_handle->proxy_changed_callback) - local_handle->proxy_changed_callback( - proxy, NULL, - local_handle->proxy_changed_user_data); - } + return CONNECTION_ERROR_NONE; } -static bool __connection_check_handle_validity(connection_h connection) +static int __connection_close_profile_set_callback(connection_handle_s *conn_handle, + void *callback, void *user_data) { - GSList *list; - - for (list = conn_handle_list; list; list = list->next) - if (connection == list->data) return true; + conn_handle->closed_callback = callback; + conn_handle->closed_user_data = user_data; - return false; + return CONNECTION_ERROR_NONE; } -static int __connection_get_handle_count(void) +static int __connection_reset_profile_set_callback(connection_handle_s *conn_handle, + void *callback, void *user_data) { - GSList *list; - int count = 0; - - if (!conn_handle_list) - return count; + conn_handle->reset_callback = callback; + conn_handle->reset_user_data = user_data; - for (list = conn_handle_list; list; list = list->next) count++; - - return count; + return CONNECTION_ERROR_NONE; } +//LCOV_EXCL_STOP /* Connection Manager ********************************************************/ -EXPORT_API int connection_create(connection_h* connection) +EXPORT_API int connection_create(connection_h *connection) { - CONNECTION_MUTEX_LOCK; + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + + int rv; if (connection == NULL || __connection_check_handle_validity(*connection)) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); - CONNECTION_MUTEX_UNLOCK; + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - if (_connection_libnet_init() == false) { - CONNECTION_LOG(CONNECTION_ERROR, "Creation failed!\n"); - CONNECTION_MUTEX_UNLOCK; - return CONNECTION_ERROR_OPERATION_FAILED; - } - *connection = g_try_malloc0(sizeof(connection_handle_s)); - if (*connection != NULL) { - CONNECTION_LOG(CONNECTION_INFO, "New Handle Created %p\n", *connection); - } else { - CONNECTION_MUTEX_UNLOCK; - return CONNECTION_ERROR_OUT_OF_MEMORY; + if (*connection != NULL) + CONNECTION_LOG(CONNECTION_INFO, "New handle created[%p]", *connection); + else + return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + rv = _connection_libnet_init(*connection); + if (rv == NET_ERR_ACCESS_DENIED) { + CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to create connection[%d]", rv); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE } - conn_handle_list = g_slist_append(conn_handle_list, *connection); + conn_handle_list = g_slist_prepend(conn_handle_list, *connection); - CONNECTION_MUTEX_UNLOCK; return CONNECTION_ERROR_NONE; } EXPORT_API int connection_destroy(connection_h connection) { - CONNECTION_MUTEX_LOCK; + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); - if (connection == NULL || !(__connection_check_handle_validity(connection))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); - CONNECTION_MUTEX_UNLOCK; + if (!(__connection_check_handle_validity(connection))) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - CONNECTION_LOG(CONNECTION_INFO, "Destroy Handle : %p\n", connection); + CONNECTION_LOG(CONNECTION_INFO, "Destroy handle: %p", connection); __connection_set_type_changed_callback(connection, NULL, NULL); __connection_set_ip_changed_callback(connection, NULL, NULL); __connection_set_proxy_changed_callback(connection, NULL, NULL); + __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL); + _connection_libnet_deinit(connection); conn_handle_list = g_slist_remove(conn_handle_list, connection); g_free(connection); + connection = NULL; - if (__connection_get_handle_count() == 0) - _connection_libnet_deinit(); - - CONNECTION_MUTEX_UNLOCK; return CONNECTION_ERROR_NONE; } +EXPORT_API int connection_create_cs(int tid, connection_h *connection) +{ + int rv; + + rv = connection_create(connection); + if (rv == CONNECTION_ERROR_NONE) + _connection_set_cs_tid(tid, *connection); + + return rv; +} + +EXPORT_API int connection_destroy_cs(int tid, connection_h connection) +{ + int rv; + + _connection_unset_cs_tid(tid, connection); + rv = connection_destroy(connection); + + return rv; +} + EXPORT_API int connection_get_type(connection_h connection, connection_type_e* type) { + int rv = 0; int status = 0; + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + if (type == NULL || !(__connection_check_handle_validity(connection))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - if (vconf_get_int(VCONFKEY_NETWORK_STATUS, &status)) { - CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed = %d\n", status); - return CONNECTION_ERROR_OPERATION_FAILED; + rv = vconf_get_int(VCONFKEY_NETWORK_STATUS, &status); + if (rv != VCONF_OK) { + CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed = %d", status); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE } - CONNECTION_LOG(CONNECTION_INFO, "Connected Network = %d\n", status); + CONNECTION_LOG(CONNECTION_INFO, "Connected Network = %d", status); *type = __connection_convert_net_state(status); @@ -322,8 +258,10 @@ EXPORT_API int connection_get_type(connection_h connection, connection_type_e* t EXPORT_API int connection_get_ip_address(connection_h connection, connection_address_family_e address_family, char** ip_address) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + if (ip_address == NULL || !(__connection_check_handle_validity(connection))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } @@ -332,139 +270,361 @@ EXPORT_API int connection_get_ip_address(connection_h connection, *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP); break; case CONNECTION_ADDRESS_FAMILY_IPV6: - CONNECTION_LOG(CONNECTION_ERROR, "Not supported yet\n"); - return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED; + *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP6); break; default: - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } if (*ip_address == NULL) { - CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed\n"); - return CONNECTION_ERROR_OPERATION_FAILED; + CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED;//LCOV_EXCL_LINE } - CONNECTION_LOG(CONNECTION_INFO, "IP Address %s\n", *ip_address); - return CONNECTION_ERROR_NONE; } EXPORT_API int connection_get_proxy(connection_h connection, connection_address_family_e address_family, char** proxy) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + if (proxy == NULL || !(__connection_check_handle_validity(connection))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } switch (address_family) { case CONNECTION_ADDRESS_FAMILY_IPV4: - *proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY); - break; case CONNECTION_ADDRESS_FAMILY_IPV6: - CONNECTION_LOG(CONNECTION_ERROR, "Not supported yet\n"); - return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED; + *proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY); break; default: - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } if (*proxy == NULL) { - CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed\n"); - return CONNECTION_ERROR_OPERATION_FAILED; + CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + return CONNECTION_ERROR_NONE; +} + +EXPORT_API int connection_get_mac_address(connection_h connection, connection_type_e type, char** mac_addr) +{ + FILE *fp; + char buf[CONNECTION_MAC_INFO_LENGTH + 1]; + + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE, ETHERNET_FEATURE); + + if (type == CONNECTION_TYPE_WIFI) + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + else if (type == CONNECTION_TYPE_ETHERNET) //LCOV_EXCL_LINE + CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE); //LCOV_EXCL_LINE + + if (mac_addr == NULL || !(__connection_check_handle_validity(connection))) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + switch (type) { + case CONNECTION_TYPE_WIFI: + if (__builtin_expect(tv_profile == -1, 0)) { + char *profileName; + system_info_get_platform_string("http://tizen.org/feature/profile", &profileName); + if (*profileName == 't' || *profileName == 'T') + tv_profile = 1; + else + tv_profile = 0; + free(profileName); + } + if (tv_profile == 1) { + fp = fopen(WIFI_MAC_INFO_FILE, "r"); + if (fp == NULL) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", WIFI_MAC_INFO_FILE); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + } + + if (fgets(buf, sizeof(buf), fp) == NULL) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", WIFI_MAC_INFO_FILE); //LCOV_EXCL_LINE + fclose(fp); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; + } + + CONNECTION_LOG(CONNECTION_INFO, "%s : %s", WIFI_MAC_INFO_FILE, buf); + + *mac_addr = (char *)malloc(CONNECTION_MAC_INFO_LENGTH + 1); + if (*mac_addr == NULL) { + CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed"); //LCOV_EXCL_LINE + fclose(fp); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + } + g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1); + fclose(fp); + } else { + *mac_addr = vconf_get_str(VCONFKEY_WIFI_BSSID_ADDRESS); + + if (*mac_addr == NULL) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to get vconf from %s", VCONFKEY_WIFI_BSSID_ADDRESS); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + } + break; + //LCOV_EXCL_START + case CONNECTION_TYPE_ETHERNET: + fp = fopen(ETHERNET_MAC_INFO_FILE, "r"); + if (fp == NULL) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", ETHERNET_MAC_INFO_FILE); + return CONNECTION_ERROR_OUT_OF_MEMORY; + } + + if (fgets(buf, sizeof(buf), fp) == NULL) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", ETHERNET_MAC_INFO_FILE); + fclose(fp); + return CONNECTION_ERROR_OPERATION_FAILED; + } + + CONNECTION_LOG(CONNECTION_INFO, "%s : %s", ETHERNET_MAC_INFO_FILE, buf); + + *mac_addr = (char *)malloc(CONNECTION_MAC_INFO_LENGTH + 1); + if (*mac_addr == NULL) { + CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed"); + fclose(fp); + return CONNECTION_ERROR_OUT_OF_MEMORY; + } + + g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1); + fclose(fp); + + break; + //LCOV_EXCL_STOP + default: + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } - CONNECTION_LOG(CONNECTION_INFO, "Proxy Address %s\n", *proxy); + /* Checking Invalid MAC Address */ + if ((strcmp(*mac_addr, "00:00:00:00:00:00") == 0) || + (strcmp(*mac_addr, "ff:ff:ff:ff:ff:ff") == 0)) { + CONNECTION_LOG(CONNECTION_ERROR, "MAC Address(%s) is invalid", *mac_addr); //LCOV_EXCL_LINE + return CONNECTION_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + } + + CONNECTION_LOG(CONNECTION_INFO, "MAC Address %s", *mac_addr); return CONNECTION_ERROR_NONE; } + +EXPORT_API int connection_is_metered_network(connection_h connection, bool* is_metered) +{ + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + + if (is_metered == NULL || !(__connection_check_handle_validity(connection))) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + int rv = _connection_libnet_get_metered_state(connection, is_metered); + if (rv != CONNECTION_ERROR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "Fail to get metered state[%d]", rv); //LCOV_EXCL_LINE + return rv; //LCOV_EXCL_LINE + } + + CONNECTION_LOG(CONNECTION_INFO, "metered state: %s", is_metered ? "true" : "false"); + return CONNECTION_ERROR_NONE; +} + + EXPORT_API int connection_get_cellular_state(connection_h connection, connection_cellular_state_e* state) { + int rv = 0; int status = 0; int cellular_state = 0; +#if defined TIZEN_DUALSIM_ENABLE + int sim_id = 0; +#endif + + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE); if (state == NULL || !(__connection_check_handle_validity(connection))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - if (!vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &status)) { - CONNECTION_LOG(CONNECTION_INFO, "Cellular = %d\n", status); - *state = __connection_convert_cellular_state(status); + rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &status); + if (rv != VCONF_OK) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } - if (*state == CONNECTION_CELLULAR_STATE_AVAILABLE) { - if (vconf_get_int(VCONFKEY_DNET_STATE, &cellular_state)) { - CONNECTION_LOG(CONNECTION_ERROR, - "vconf_get_int Failed = %d\n", cellular_state); - return CONNECTION_ERROR_OPERATION_FAILED; - } + CONNECTION_LOG(CONNECTION_INFO, "Cellular: %d", status); + *state = __connection_convert_cellular_state(status); + + if (*state == CONNECTION_CELLULAR_STATE_AVAILABLE) { +#if defined TIZEN_DUALSIM_ENABLE + rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id); + if (rv != VCONF_OK) { + CONNECTION_LOG(CONNECTION_ERROR, + "Failed to get default subscriber id", sim_id); + return CONNECTION_ERROR_OPERATION_FAILED; } - CONNECTION_LOG(CONNECTION_INFO, "Connection state = %d\n", cellular_state); + switch (sim_id) { + case CONNECTION_CELLULAR_SUBSCRIBER_1: +#endif + rv = vconf_get_int(VCONFKEY_DNET_STATE, &cellular_state); +#if defined TIZEN_DUALSIM_ENABLE + break; - if (cellular_state == VCONFKEY_DNET_NORMAL_CONNECTED || - cellular_state == VCONFKEY_DNET_SECURE_CONNECTED || - cellular_state == VCONFKEY_DNET_TRANSFER) - *state = CONNECTION_CELLULAR_STATE_CONNECTED; + case CONNECTION_CELLULAR_SUBSCRIBER_2: + rv = vconf_get_int(VCONFKEY_DNET_STATE2, &cellular_state); + break; - return CONNECTION_ERROR_NONE; - } else { - CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed = %d\n", status); - return CONNECTION_ERROR_OPERATION_FAILED; + default: + CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id); + return CONNECTION_ERROR_OPERATION_FAILED; + } +#endif + if (rv != VCONF_OK) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } } + + CONNECTION_LOG(CONNECTION_INFO, "Cellular state: %d", cellular_state); + + if (cellular_state == VCONFKEY_DNET_NORMAL_CONNECTED || + cellular_state == VCONFKEY_DNET_SECURE_CONNECTED || + cellular_state == VCONFKEY_DNET_TRANSFER) + *state = CONNECTION_CELLULAR_STATE_CONNECTED; + + return CONNECTION_ERROR_NONE; } EXPORT_API int connection_get_wifi_state(connection_h connection, connection_wifi_state_e* state) { + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + if (state == NULL || !(__connection_check_handle_validity(connection))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - if (_connection_libnet_get_wifi_state(state) == false) { - CONNECTION_LOG(CONNECTION_ERROR, "Fail to get wifi state\n"); - return CONNECTION_ERROR_OPERATION_FAILED; + int rv = _connection_libnet_get_wifi_state(connection, state); + if (rv != CONNECTION_ERROR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "Fail to get Wi-Fi state[%d]", rv); //LCOV_EXCL_LINE + return rv; //LCOV_EXCL_LINE } - CONNECTION_LOG(CONNECTION_INFO, "WiFi state = %d\n", *state); + CONNECTION_LOG(CONNECTION_INFO, "Wi-Fi state: %d", *state); return CONNECTION_ERROR_NONE; } -EXPORT_API int connection_get_ethernet_state(connection_h connection, connection_ethernet_state_e* state) +//LCOV_EXCL_START +EXPORT_API int connection_get_ethernet_state(connection_h connection, connection_ethernet_state_e *state) { + CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE); + if (state == NULL || !(__connection_check_handle_validity(connection))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - if (_connection_libnet_get_ethernet_state(state) == false) - return CONNECTION_ERROR_OPERATION_FAILED; - - return CONNECTION_ERROR_NONE; + return _connection_libnet_get_ethernet_state(connection, state); } -EXPORT_API int connection_get_bt_state(connection_h connection, connection_bt_state_e* state) +EXPORT_API int connection_get_ethernet_cable_state(connection_h connection, connection_ethernet_cable_state_e *state) { + CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE); + if (state == NULL || !(__connection_check_handle_validity(connection))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - if (_connection_libnet_get_bluetooth_state(state) == false) - return CONNECTION_ERROR_OPERATION_FAILED; + return _connection_libnet_get_ethernet_cable_state(connection, state); +} - return CONNECTION_ERROR_NONE; +EXPORT_API int connection_set_ethernet_cable_state_chaged_cb(connection_h connection, + connection_ethernet_cable_state_chaged_cb callback, void *user_data) +{ + DEPRECATED_LOG(__FUNCTION__, "connection_set_ethernet_cable_state_changed_cb"); + CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE); + + if (callback == NULL || !(__connection_check_handle_validity(connection))) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + DEPRECATED_LOG("connection_ethernet_cable_state_chaged_cb", + "connection_ethernet_cable_state_changed_cb"); + + return __connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data); +} + +EXPORT_API int connection_unset_ethernet_cable_state_chaged_cb(connection_h connection) +{ + DEPRECATED_LOG(__FUNCTION__, "connection_unset_ethernet_cable_state_changed_cb"); + CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE); + + if (!(__connection_check_handle_validity(connection))) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + return __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL); +} + +EXPORT_API int connection_set_ethernet_cable_state_changed_cb(connection_h connection, + connection_ethernet_cable_state_changed_cb callback, void *user_data) +{ + CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE); + + if (callback == NULL || !(__connection_check_handle_validity(connection))) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + return __connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data); +} + +EXPORT_API int connection_unset_ethernet_cable_state_changed_cb(connection_h connection) +{ + CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE); + + if (!(__connection_check_handle_validity(connection))) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + return __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL); +} +//LCOV_EXCL_STOP + +EXPORT_API int connection_get_bt_state(connection_h connection, connection_bt_state_e *state) +{ + CHECK_FEATURE_SUPPORTED(TETHERING_BLUETOOTH_FEATURE); + + if (state == NULL || !(__connection_check_handle_validity(connection))) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + return _connection_libnet_get_bluetooth_state(connection, state); } EXPORT_API int connection_set_type_changed_cb(connection_h connection, connection_type_changed_cb callback, void* user_data) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + if (callback == NULL || !(__connection_check_handle_validity(connection))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } @@ -473,8 +633,10 @@ EXPORT_API int connection_set_type_changed_cb(connection_h connection, EXPORT_API int connection_unset_type_changed_cb(connection_h connection) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + if (!(__connection_check_handle_validity(connection))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } @@ -484,8 +646,10 @@ EXPORT_API int connection_unset_type_changed_cb(connection_h connection) EXPORT_API int connection_set_ip_address_changed_cb(connection_h connection, connection_address_changed_cb callback, void* user_data) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + if (callback == NULL || !(__connection_check_handle_validity(connection))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } @@ -494,8 +658,10 @@ EXPORT_API int connection_set_ip_address_changed_cb(connection_h connection, EXPORT_API int connection_unset_ip_address_changed_cb(connection_h connection) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + if (!(__connection_check_handle_validity(connection))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } @@ -505,8 +671,10 @@ EXPORT_API int connection_unset_ip_address_changed_cb(connection_h connection) EXPORT_API int connection_set_proxy_address_changed_cb(connection_h connection, connection_address_changed_cb callback, void* user_data) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + if (callback == NULL || !(__connection_check_handle_validity(connection))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } @@ -515,8 +683,10 @@ EXPORT_API int connection_set_proxy_address_changed_cb(connection_h connection, EXPORT_API int connection_unset_proxy_address_changed_cb(connection_h connection) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + if (!(__connection_check_handle_validity(connection))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } @@ -525,25 +695,37 @@ EXPORT_API int connection_unset_proxy_address_changed_cb(connection_h connection EXPORT_API int connection_add_profile(connection_h connection, connection_profile_h profile) { + int rv = 0; + connection_handle_s *conn_handle = (connection_handle_s *)connection; + net_profile_info_t *profile_info = (net_profile_info_t *)profile; + + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE); + if (!(__connection_check_handle_validity(connection)) || !(_connection_libnet_check_profile_validity(profile))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - int rv = 0; - - net_profile_info_t *profile_info = profile; - if (profile_info->profile_type != NET_DEVICE_CELLULAR) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); - return CONNECTION_ERROR_INVALID_PARAMETER; + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } - rv = net_add_profile(profile_info->ProfileInfo.Pdp.ServiceType, (net_profile_info_t*)profile); - if (rv != NET_ERR_NONE) { - CONNECTION_LOG(CONNECTION_ERROR, "net_add_profile Failed = %d\n", rv); - return CONNECTION_ERROR_OPERATION_FAILED; + if (profile_info->ProfileInfo.Pdp.PSModemPath[0] != '/' || + strlen(profile_info->ProfileInfo.Pdp.PSModemPath) < 2) { + CONNECTION_LOG(CONNECTION_ERROR, "Modem object path is NULL"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + rv = net_add_profile(conn_handle->network_info_handle, + profile_info->ProfileInfo.Pdp.ServiceType, profile_info); + if (rv == NET_ERR_ACCESS_DENIED) { + CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to add profile[%d]", rv); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE } return CONNECTION_ERROR_NONE; @@ -551,25 +733,32 @@ EXPORT_API int connection_add_profile(connection_h connection, connection_profil EXPORT_API int connection_remove_profile(connection_h connection, connection_profile_h profile) { + int rv = 0; + connection_handle_s *conn_handle = (connection_handle_s *)connection; + net_profile_info_t *profile_info = (net_profile_info_t *)profile; + + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE); + if (!(__connection_check_handle_validity(connection)) || - !(_connection_libnet_check_profile_validity(profile))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + !(_connection_libnet_check_profile_validity(profile))) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - int rv = 0; - net_profile_info_t *profile_info = profile; - if (profile_info->profile_type != NET_DEVICE_CELLULAR && + profile_info->profile_type != NET_DEVICE_MESH && profile_info->profile_type != NET_DEVICE_WIFI) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); - return CONNECTION_ERROR_INVALID_PARAMETER; + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } - rv = net_delete_profile(profile_info->ProfileName); - if (rv != NET_ERR_NONE) { - CONNECTION_LOG(CONNECTION_ERROR, "net_delete_profile Failed = %d\n", rv); - return CONNECTION_ERROR_OPERATION_FAILED; + rv = net_delete_profile(conn_handle->network_info_handle, profile_info->ProfileName); + if (rv == NET_ERR_ACCESS_DENIED) { + CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to delete profile[%d]", rv); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE } return CONNECTION_ERROR_NONE; @@ -577,19 +766,26 @@ EXPORT_API int connection_remove_profile(connection_h connection, connection_pro EXPORT_API int connection_update_profile(connection_h connection, connection_profile_h profile) { + int rv = 0; + connection_handle_s *conn_handle = (connection_handle_s *)connection; + net_profile_info_t *profile_info = (net_profile_info_t *)profile; + + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE); + if (!(__connection_check_handle_validity(connection)) || !(_connection_libnet_check_profile_validity(profile))) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - int rv = 0; - net_profile_info_t *profile_info = profile; - - rv = net_modify_profile(profile_info->ProfileName, (net_profile_info_t*)profile); - if (rv != NET_ERR_NONE) { - CONNECTION_LOG(CONNECTION_ERROR, "net_modify_profile Failed = %d\n", rv); - return CONNECTION_ERROR_OPERATION_FAILED; + rv = net_modify_profile(conn_handle->network_info_handle, + profile_info->ProfileName, (net_profile_info_t*)profile); + if (rv == NET_ERR_ACCESS_DENIED) { + CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to modify profile[%d]", rv); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE } return CONNECTION_ERROR_NONE; @@ -598,155 +794,403 @@ EXPORT_API int connection_update_profile(connection_h connection, connection_pro EXPORT_API int connection_get_profile_iterator(connection_h connection, connection_iterator_type_e type, connection_profile_iterator_h* profile_iterator) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + if (!(__connection_check_handle_validity(connection)) || (type != CONNECTION_ITERATOR_TYPE_REGISTERED && - type != CONNECTION_ITERATOR_TYPE_CONNECTED)) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + type != CONNECTION_ITERATOR_TYPE_CONNECTED && + type != CONNECTION_ITERATOR_TYPE_DEFAULT)) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - return _connection_libnet_get_profile_iterator(type, profile_iterator); + return _connection_libnet_get_profile_iterator(connection, type, profile_iterator); } EXPORT_API int connection_profile_iterator_next(connection_profile_iterator_h profile_iterator, connection_profile_h* profile) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + return _connection_libnet_get_iterator_next(profile_iterator, profile); } EXPORT_API bool connection_profile_iterator_has_next(connection_profile_iterator_h profile_iterator) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + return _connection_libnet_iterator_has_next(profile_iterator); } EXPORT_API int connection_destroy_profile_iterator(connection_profile_iterator_h profile_iterator) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + return _connection_libnet_destroy_iterator(profile_iterator); } EXPORT_API int connection_get_current_profile(connection_h connection, connection_profile_h* profile) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + if (!(__connection_check_handle_validity(connection)) || profile == NULL) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - return _connection_libnet_get_current_profile(profile); + return _connection_libnet_get_current_profile(connection, profile); } -EXPORT_API int connection_get_default_cellular_service_profile(connection_h connection, - connection_cellular_service_type_e type, connection_profile_h* profile) +EXPORT_API int connection_get_default_cellular_service_profile( + connection_h connection, connection_cellular_service_type_e type, + connection_profile_h *profile) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE); + if (!(__connection_check_handle_validity(connection)) || profile == NULL) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - return _connection_libnet_get_cellular_service_profile(type, profile); + return _connection_libnet_get_cellular_service_profile(connection, type, profile); } EXPORT_API int connection_set_default_cellular_service_profile(connection_h connection, connection_cellular_service_type_e type, connection_profile_h profile) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE); + if (!(__connection_check_handle_validity(connection)) || profile == NULL) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - return _connection_libnet_set_cellular_service_profile_sync(type, profile); + return _connection_libnet_set_cellular_service_profile_sync(connection, type, profile); } EXPORT_API int connection_set_default_cellular_service_profile_async(connection_h connection, connection_cellular_service_type_e type, connection_profile_h profile, connection_set_default_cb callback, void* user_data) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE); + + int rv; + if (!(__connection_check_handle_validity(connection)) || profile == NULL || callback == NULL) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - return _connection_libnet_set_cellular_service_profile_async(type, profile, callback, user_data); + rv = _connection_libnet_set_cellular_service_profile_async(connection, type, profile); + if (rv == NET_ERR_ACCESS_DENIED) { + CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to set default cellular service profile[%d]", rv); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + __connection_set_default_cellular_service_profile_callback(connection, callback, user_data); + + return CONNECTION_ERROR_NONE; } EXPORT_API int connection_open_profile(connection_h connection, connection_profile_h profile, connection_opened_cb callback, void* user_data) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE); + + int rv; + if (!(__connection_check_handle_validity(connection)) || profile == NULL || callback == NULL) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - return _connection_libnet_open_profile(profile, callback, user_data); + rv = _connection_libnet_open_profile(connection, profile); + if (rv == NET_ERR_ACCESS_DENIED) { + CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to open profile[%d]", rv); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + __connection_open_profile_set_callback(connection, callback, user_data); + + return CONNECTION_ERROR_NONE; } EXPORT_API int connection_close_profile(connection_h connection, connection_profile_h profile, connection_closed_cb callback, void* user_data) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE); + + int rv; + if (!(__connection_check_handle_validity(connection)) || profile == NULL || callback == NULL) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - return _connection_libnet_close_profile(profile, callback, user_data); + rv = _connection_libnet_close_profile(connection, profile); + if (rv == NET_ERR_ACCESS_DENIED) { + CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to close profile[%d]", rv); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + __connection_close_profile_set_callback(connection, callback, user_data); + + return CONNECTION_ERROR_NONE; +} + +EXPORT_API int connection_reset_profile(connection_h connection, + connection_reset_option_e type, int id, connection_reset_cb callback, void *user_data) +{ + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE); + + int rv; + + if (!(__connection_check_handle_validity(connection))) { + CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + if (id < 0 || id > 1) { + CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + rv = _connection_libnet_reset_profile(connection, type, id); + if (rv == NET_ERR_ACCESS_DENIED) { + CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to reset profile[%d]", rv); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + __connection_reset_profile_set_callback(connection, callback, user_data); + + return CONNECTION_ERROR_NONE; } EXPORT_API int connection_add_route(connection_h connection, const char* interface_name, const char* host_address) { + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + if (!(__connection_check_handle_validity(connection)) || interface_name == NULL || host_address == NULL) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); return CONNECTION_ERROR_INVALID_PARAMETER; } - return _connection_libnet_add_route(interface_name, host_address); + return _connection_libnet_add_route(connection, interface_name, host_address); } +EXPORT_API int connection_remove_route(connection_h connection, const char* interface_name, const char* host_address) +{ + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); -/* Connection Statistics module ******************************************************************/ + if (!(__connection_check_handle_validity(connection)) || + interface_name == NULL || host_address == NULL) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + return _connection_libnet_remove_route(connection, interface_name, host_address); +} -static int __get_statistic(connection_type_e connection_type, - connection_statistics_type_e statistics_type, long long* llsize) +EXPORT_API int connection_add_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway) { - int size; - unsigned long long ull_size; - int stat_type; - char *key = NULL; + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE); + + if (!(__connection_check_handle_validity(connection)) || + interface_name == NULL || host_address == NULL) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + return _connection_libnet_add_route_ipv6(connection, interface_name, host_address, gateway); +} + +EXPORT_API int connection_remove_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway) +{ + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE); + + if (!(__connection_check_handle_validity(connection)) || + interface_name == NULL || host_address == NULL) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + return _connection_libnet_remove_route_ipv6(connection, interface_name, host_address, gateway); +} + +EXPORT_API int connection_add_route_entry(connection_h connection, + connection_address_family_e address_family, const char *interface_name, + const char *host_address, const char *gateway) +{ + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE); + + if (!(__connection_check_handle_validity(connection)) || + (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 && + address_family != CONNECTION_ADDRESS_FAMILY_IPV6) || + interface_name == NULL || host_address == NULL) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) + return _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4, + interface_name, host_address, gateway); + else + return _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6, + interface_name, host_address, gateway); + + return CONNECTION_ERROR_NONE; +} + +EXPORT_API int connection_remove_route_entry(connection_h connection, + connection_address_family_e address_family, const char *interface_name, + const char *host_address, const char *gateway) +{ + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE); + + if (!(__connection_check_handle_validity(connection)) || + (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 && + address_family != CONNECTION_ADDRESS_FAMILY_IPV6) || + interface_name == NULL || host_address == NULL) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) + return _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4, + interface_name, host_address, gateway); + else + return _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6, + interface_name, host_address, gateway); + + return CONNECTION_ERROR_NONE; +} + +static int __get_cellular_statistic(connection_statistics_type_e statistics_type, long long *llsize) +{ + int rv = VCONF_OK, rv1 = VCONF_OK; + int last_size = 0, size = 0; +#if defined TIZEN_DUALSIM_ENABLE + int sim_id = 0; +#endif if (llsize == NULL) { - CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n"); + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + switch (statistics_type) { + case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA: + case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA: + case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA: + case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA: + break; + default: return CONNECTION_ERROR_INVALID_PARAMETER; } - if (connection_type == CONNECTION_TYPE_CELLULAR) { +#if defined TIZEN_DUALSIM_ENABLE + rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id); + if (rv != VCONF_OK) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to get default subscriber id"); + *llsize = 0; + return CONNECTION_ERROR_OPERATION_FAILED; + } + + switch (sim_id) { + case 0: +#endif switch (statistics_type) { case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA: - key = VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT; + rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size); break; case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA: - key = VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV; + rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size); break; case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA: - key = VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT; + rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size); + rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT, &size); break; case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA: - key = VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV; + rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size); + rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV, &size); break; - default: - return CONNECTION_ERROR_INVALID_PARAMETER; } - - if (vconf_get_int(key, &size)) { - CONNECTION_LOG(CONNECTION_ERROR, "Cannot Get %s = %d\n", key, size); - *llsize = 0; - return CONNECTION_ERROR_OPERATION_FAILED; +#if defined TIZEN_DUALSIM_ENABLE + break; + case 1: + switch (statistics_type) { + case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA: + rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size); + break; + case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA: + rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size); + break; + case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA: + rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size); + rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT2, &size); + break; + case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA: + rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size); + rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV2, &size); + break; } + break; + default: + *llsize = 0; + CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id); + return CONNECTION_ERROR_OPERATION_FAILED; + } +#endif + + if (rv != VCONF_OK || rv1 != VCONF_OK) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular statistics"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + *llsize = (long long)(last_size * 1000) + (long long)(size * 1000); + CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", *llsize); - CONNECTION_LOG(CONNECTION_INFO,"%s:%d bytes\n", key, size); - *llsize = (long long)size; - } else if (connection_type == CONNECTION_TYPE_WIFI) { + return CONNECTION_ERROR_NONE; +} + +static int __get_statistic(connection_handle_s *conn_handle, connection_type_e connection_type, + connection_statistics_type_e statistics_type, long long *llsize) +{ + int rv, stat_type; + unsigned long long ull_size; + + if (llsize == NULL) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + rv = _connection_libnet_check_get_privilege(); + if (rv == CONNECTION_ERROR_PERMISSION_DENIED) + return rv; + else if (rv != CONNECTION_ERROR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to get statistics"); //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; + } + + if (connection_type == CONNECTION_TYPE_CELLULAR) + return __get_cellular_statistic(statistics_type, llsize); + else if (connection_type == CONNECTION_TYPE_WIFI) { switch (statistics_type) { case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA: stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA; @@ -764,13 +1208,16 @@ static int __get_statistic(connection_type_e connection_type, return CONNECTION_ERROR_INVALID_PARAMETER; } - if (_connection_libnet_get_statistics(stat_type, &ull_size) != CONNECTION_ERROR_NONE) { - CONNECTION_LOG(CONNECTION_ERROR, "Cannot Get Wi-Fi statistics : %d\n", ull_size); - *llsize = 0; - return CONNECTION_ERROR_OPERATION_FAILED; + rv = _connection_libnet_get_statistics(conn_handle, stat_type, &ull_size); + if (rv == CONNECTION_ERROR_PERMISSION_DENIED) + return rv; + else if (rv != CONNECTION_ERROR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to get Wi-Fi statistics"); //LCOV_EXCL_LINE + *llsize = 0; //LCOV_EXCL_LINE + return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE } - CONNECTION_LOG(CONNECTION_INFO,"%d bytes\n", ull_size); + CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", ull_size); *llsize = (long long)ull_size; } else return CONNECTION_ERROR_INVALID_PARAMETER; @@ -778,8 +1225,8 @@ static int __get_statistic(connection_type_e connection_type, return CONNECTION_ERROR_NONE; } -static int __reset_statistic(connection_type_e connection_type, - connection_statistics_type_e statistics_type) +static int __reset_statistic(connection_handle_s *conn_handle, + connection_type_e connection_type, connection_statistics_type_e statistics_type) { int conn_type; int stat_type; @@ -809,24 +1256,160 @@ static int __reset_statistic(connection_type_e connection_type, return CONNECTION_ERROR_INVALID_PARAMETER; } - rv = _connection_libnet_set_statistics(conn_type, stat_type); - if(rv != CONNECTION_ERROR_NONE) + rv = _connection_libnet_set_statistics(conn_handle, conn_type, stat_type); + if (rv != CONNECTION_ERROR_NONE) return rv; - - CONNECTION_LOG(CONNECTION_INFO,"connection_reset_statistics success\n"); + CONNECTION_LOG(CONNECTION_INFO, "connection_reset_statistics success"); return CONNECTION_ERROR_NONE; } -EXPORT_API int connection_get_statistics(connection_type_e connection_type, +EXPORT_API int connection_get_statistics(connection_h connection, + connection_type_e connection_type, connection_statistics_type_e statistics_type, long long* size) { - return __get_statistic(connection_type, statistics_type, size); + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE); + + if (connection_type == CONNECTION_TYPE_CELLULAR) + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE); + else if (connection_type == CONNECTION_TYPE_WIFI) + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__connection_check_handle_validity(connection)) || size == NULL) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + return __get_statistic(connection, connection_type, statistics_type, size); } -EXPORT_API int connection_reset_statistics(connection_type_e connection_type, +EXPORT_API int connection_reset_statistics(connection_h connection, + connection_type_e connection_type, connection_statistics_type_e statistics_type) { - return __reset_statistic(connection_type, statistics_type); + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE); + + if (connection_type == CONNECTION_TYPE_CELLULAR) + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE); + else if (connection_type == CONNECTION_TYPE_WIFI) + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!__connection_check_handle_validity(connection)) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + return __reset_statistic(connection, connection_type, statistics_type); +} + +EXPORT_API int connection_foreach_ipv6_address(connection_h connection, + connection_type_e connection_type, connection_ipv6_address_cb callback, + void *user_data) +{ + CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, + TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE); + + GSList *ipv6_address_list = NULL; + + if (!(__connection_check_handle_validity(connection))) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + int rv = CONNECTION_ERROR_NONE; + + switch (connection_type) { + case CONNECTION_TYPE_WIFI: + rv = net_foreach_ipv6_address(NET_DEVICE_WIFI, + &ipv6_address_list); + break; + case CONNECTION_TYPE_CELLULAR: + rv = net_foreach_ipv6_address(NET_DEVICE_CELLULAR, + &ipv6_address_list); + break; + case CONNECTION_TYPE_ETHERNET: + rv = net_foreach_ipv6_address(NET_DEVICE_ETHERNET, + &ipv6_address_list); + break; + case CONNECTION_TYPE_BT: + rv = net_foreach_ipv6_address(NET_DEVICE_BLUETOOTH, + &ipv6_address_list); + break; + default: + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + if (rv != NET_ERR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "net_get_multiple_id_address" + " Failed = %d\n", rv); + return CONNECTION_ERROR_OPERATION_FAILED; + } + + GSList *list; + for (list = ipv6_address_list; list; list = list->next) { + rv = callback((char *)list->data, user_data); + if (rv == false) + break; + } + + g_slist_free_full(ipv6_address_list, g_free); + ipv6_address_list = NULL; + + return CONNECTION_ERROR_NONE; +} + +EXPORT_API int connection_profile_start_tcpdump(connection_h connection) +{ + int ret = 0; + + if (!(__connection_check_handle_validity(connection))) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + ret = _connection_libnet_start_tcpdump(connection); + if (ret != CONNECTION_ERROR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to start tcpdump (%d)", ret); + return ret; + } + + return CONNECTION_ERROR_NONE; +} + +EXPORT_API int connection_profile_stop_tcpdump(connection_h connection) +{ + int ret = 0; + + if (!(__connection_check_handle_validity(connection))) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + ret = _connection_libnet_stop_tcpdump(connection); + if (ret != CONNECTION_ERROR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to stop tcpdump (%d)", ret); + return ret; + } + + return CONNECTION_ERROR_NONE; +} + +EXPORT_API int connection_profile_get_tcpdump_state(connection_h connection, gboolean *tcpdump_state) +{ + int ret = 0; + + if (!(__connection_check_handle_validity(connection)) || !tcpdump_state) { + CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); + return CONNECTION_ERROR_INVALID_PARAMETER; + } + + ret = _connection_libnet_get_tcpdump_state(connection, tcpdump_state); + if (ret != CONNECTION_ERROR_NONE) { + CONNECTION_LOG(CONNECTION_ERROR, "Failed to get the tcpdump state (%d)", ret); + return ret; + } + + return CONNECTION_ERROR_NONE; }