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);
-
static int __connection_convert_net_state(int status)
{
switch (status) {
return count;
}
+static void __connection_cb_ethernet_cable_state_changed_cb(connection_ethernet_cable_state_e state)
+{
+ CONNECTION_LOG(CONNECTION_INFO, "Ethernet Cable state Indication");
+
+ GSList *list;
+
+ for (list = conn_handle_list; list; list = list->next) {
+ connection_handle_s *local_handle = (connection_handle_s *)list->data;
+ if (local_handle->ethernet_cable_state_changed_callback)
+ local_handle->ethernet_cable_state_changed_callback(state,
+ local_handle->ethernet_cable_state_changed_user_data);
+ }
+}
+
+static int __connection_get_ethernet_cable_state_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->ethernet_cable_state_changed_callback) count++;
+ }
+
+ return count;
+}
+
static int __connection_set_type_changed_callback(connection_h connection,
void *callback, void *user_data)
{
__connection_cb_state_change_cb, NULL))
return CONNECTION_ERROR_OPERATION_FAILED;
- local_handle->state_changed_user_data = user_data;
+ local_handle->type_changed_user_data = user_data;
} else {
if (local_handle->type_changed_callback &&
__connection_get_type_changed_callback_count() == 1)
if (local_handle->type_changed_callback)
local_handle->type_changed_callback(
__connection_convert_net_state(state),
- local_handle->state_changed_user_data);
+ local_handle->type_changed_user_data);
}
}
static bool __connection_check_handle_validity(connection_h connection)
{
- GSList *list;
+ bool ret = false;
- for (list = conn_handle_list; list; list = list->next)
- if (connection == list->data) return true;
+ if (connection == NULL)
+ return false;
- return false;
+ if (g_slist_find(conn_handle_list, connection) != NULL)
+ ret = true;
+
+ return ret;
+}
+
+static int __connection_set_ethernet_cable_state_changed_cb(connection_h connection,
+ connection_ethernet_cable_state_chaged_cb callback, void *user_data)
+{
+ connection_handle_s *local_handle = (connection_handle_s *)connection;
+
+ if (callback) {
+ if (__connection_get_ethernet_cable_state_changed_callback_count() == 0)
+ _connection_libnet_set_ethernet_cable_state_changed_cb(
+ __connection_cb_ethernet_cable_state_changed_cb);
+
+ } else {
+ if (__connection_get_ethernet_cable_state_changed_callback_count() == 1)
+ _connection_libnet_set_ethernet_cable_state_changed_cb(NULL);
+ }
+
+ local_handle->ethernet_cable_state_changed_callback = callback;
+ local_handle->ethernet_cable_state_changed_user_data = user_data;
+ return CONNECTION_ERROR_NONE;
}
static int __connection_get_handle_count(void)
return count;
}
-/* Connection Manager module ********************************************************************/
-
-int connection_create(connection_h* connection)
+/* Connection Manager ********************************************************/
+EXPORT_API int connection_create(connection_h* connection)
{
CONNECTION_MUTEX_LOCK;
-
+ int rv;
if (connection == NULL || __connection_check_handle_validity(*connection)) {
CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
CONNECTION_MUTEX_UNLOCK;
return CONNECTION_ERROR_INVALID_PARAMETER;
}
- if (_connection_libnet_init() == false) {
- CONNECTION_LOG(CONNECTION_ERROR, "Creation failed!\n");
+ rv = _connection_libnet_init();
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
+ CONNECTION_MUTEX_UNLOCK;
+ return CONNECTION_ERROR_PERMISSION_DENIED;
+ }
+ else if (rv != NET_ERR_NONE) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Failed to create connection[%d]", rv);
CONNECTION_MUTEX_UNLOCK;
return CONNECTION_ERROR_OPERATION_FAILED;
}
return CONNECTION_ERROR_NONE;
}
-int connection_destroy(connection_h connection)
+EXPORT_API int connection_destroy(connection_h connection)
{
CONNECTION_MUTEX_LOCK;
__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);
conn_handle_list = g_slist_remove(conn_handle_list, connection);
return CONNECTION_ERROR_NONE;
}
-int connection_get_type(connection_h connection, connection_type_e* type)
+EXPORT_API int connection_get_type(connection_h connection, connection_type_e* type)
{
int status = 0;
return CONNECTION_ERROR_NONE;
}
-int connection_get_ip_address(connection_h connection,
+EXPORT_API int connection_get_ip_address(connection_h connection,
connection_address_family_e address_family, char** ip_address)
{
if (ip_address == NULL || !(__connection_check_handle_validity(connection))) {
return CONNECTION_ERROR_OPERATION_FAILED;
}
- CONNECTION_LOG(CONNECTION_INFO, "IP Address %s\n", *ip_address);
-
return CONNECTION_ERROR_NONE;
}
-int connection_get_proxy(connection_h connection,
+EXPORT_API int connection_get_proxy(connection_h connection,
connection_address_family_e address_family, char** proxy)
{
if (proxy == NULL || !(__connection_check_handle_validity(connection))) {
return CONNECTION_ERROR_OPERATION_FAILED;
}
- CONNECTION_LOG(CONNECTION_INFO, "Proxy Address %s\n", *proxy);
+ 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];
+
+ 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:
+ fp = fopen(WIFI_MAC_INFO_FILE, "r");
+ if (fp == NULL) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", WIFI_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", WIFI_MAC_INFO_FILE);
+ fclose(fp);
+ 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");
+ fclose(fp);
+ return CONNECTION_ERROR_OUT_OF_MEMORY;
+ }
+ g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1);
+ fclose(fp);
+ break;
+ 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;
+ default:
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ /* 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);
+ return CONNECTION_ERROR_INVALID_OPERATION;
+ }
+
+ CONNECTION_LOG(CONNECTION_INFO, "MAC Address %s", *mac_addr);
return CONNECTION_ERROR_NONE;
}
-int connection_get_cellular_state(connection_h connection, connection_cellular_state_e* state)
+EXPORT_API int connection_get_cellular_state(connection_h connection, connection_cellular_state_e* state)
{
int status = 0;
int cellular_state = 0;
}
}
-int connection_get_wifi_state(connection_h connection, connection_wifi_state_e* state)
+EXPORT_API int connection_get_wifi_state(connection_h connection, connection_wifi_state_e* state)
{
+ int rv;
+
if (state == NULL || !(__connection_check_handle_validity(connection))) {
CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
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;
+ rv = _connection_libnet_get_wifi_state(state);
+ if (rv != CONNECTION_ERROR_NONE) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Fail to get Wi-Fi state[%d]", rv);
+ return rv;
}
CONNECTION_LOG(CONNECTION_INFO, "WiFi state = %d\n", *state);
return CONNECTION_ERROR_NONE;
}
-int connection_get_ethernet_state(connection_h connection, connection_ethernet_state_e* state)
+EXPORT_API int connection_get_ethernet_state(connection_h connection, connection_ethernet_state_e* state)
{
if (state == NULL || !(__connection_check_handle_validity(connection))) {
CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
- if (_connection_libnet_get_ethernet_state(state) == false)
- return CONNECTION_ERROR_OPERATION_FAILED;
+ return _connection_libnet_get_ethernet_state(state);
+}
- return CONNECTION_ERROR_NONE;
+EXPORT_API int connection_get_ethernet_cable_state(connection_h connection, connection_ethernet_cable_state_e *state)
+{
+ if (state == NULL || !(__connection_check_handle_validity(connection))) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ return _connection_libnet_get_ethernet_cable_state(state);
+}
+
+EXPORT_API int connection_set_ethernet_cable_state_chaged_cb(connection_h connection,
+ connection_ethernet_cable_state_chaged_cb callback, void *user_data)
+{
+ 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_chaged_cb(connection_h connection)
+{
+ 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);
}
-int connection_get_bt_state(connection_h connection, connection_bt_state_e* state)
+EXPORT_API int connection_get_bt_state(connection_h connection, connection_bt_state_e* state)
{
if (state == NULL || !(__connection_check_handle_validity(connection))) {
CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
- if (_connection_libnet_get_bluetooth_state(state) == false)
- return CONNECTION_ERROR_OPERATION_FAILED;
+ return _connection_libnet_get_bluetooth_state(state);
- return CONNECTION_ERROR_NONE;
}
-int connection_set_type_changed_cb(connection_h connection,
+EXPORT_API int connection_set_type_changed_cb(connection_h connection,
connection_type_changed_cb callback, void* user_data)
{
if (callback == NULL || !(__connection_check_handle_validity(connection))) {
return __connection_set_type_changed_callback(connection, callback, user_data);
}
-int connection_unset_type_changed_cb(connection_h connection)
+EXPORT_API int connection_unset_type_changed_cb(connection_h connection)
{
if (!(__connection_check_handle_validity(connection))) {
CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
return __connection_set_type_changed_callback(connection, NULL, NULL);
}
-int connection_set_ip_address_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)
{
if (callback == NULL || !(__connection_check_handle_validity(connection))) {
return __connection_set_ip_changed_callback(connection, callback, user_data);
}
-int connection_unset_ip_address_changed_cb(connection_h connection)
+EXPORT_API int connection_unset_ip_address_changed_cb(connection_h connection)
{
if (!(__connection_check_handle_validity(connection))) {
CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
return __connection_set_ip_changed_callback(connection, NULL, NULL);
}
-int connection_set_proxy_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)
{
if (callback == NULL || !(__connection_check_handle_validity(connection))) {
return __connection_set_proxy_changed_callback(connection, callback, user_data);
}
-int connection_unset_proxy_address_changed_cb(connection_h connection)
+EXPORT_API int connection_unset_proxy_address_changed_cb(connection_h connection)
{
if (!(__connection_check_handle_validity(connection))) {
CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
return __connection_set_proxy_changed_callback(connection, NULL, NULL);
}
-int connection_add_profile(connection_h connection, connection_profile_h profile)
+EXPORT_API int connection_add_profile(connection_h connection, connection_profile_h profile)
{
if (!(__connection_check_handle_validity(connection)) ||
!(_connection_libnet_check_profile_validity(profile))) {
}
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);
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
+ return CONNECTION_ERROR_PERMISSION_DENIED;
+ } else if (rv != NET_ERR_NONE) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Failed to add profile[%d]", rv);
return CONNECTION_ERROR_OPERATION_FAILED;
}
return CONNECTION_ERROR_NONE;
}
-int connection_remove_profile(connection_h connection, connection_profile_h profile)
+EXPORT_API int connection_remove_profile(connection_h connection, connection_profile_h profile)
{
if (!(__connection_check_handle_validity(connection)) ||
!(_connection_libnet_check_profile_validity(profile))) {
}
rv = net_delete_profile(profile_info->ProfileName);
- if (rv != NET_ERR_NONE) {
- CONNECTION_LOG(CONNECTION_ERROR, "net_delete_profile Failed = %d\n", rv);
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
+ return CONNECTION_ERROR_PERMISSION_DENIED;
+ } else if (rv != NET_ERR_NONE) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Failed to delete profile[%d]", rv);
return CONNECTION_ERROR_OPERATION_FAILED;
}
return CONNECTION_ERROR_NONE;
}
-int connection_update_profile(connection_h connection, connection_profile_h profile)
+EXPORT_API int connection_update_profile(connection_h connection, connection_profile_h profile)
{
if (!(__connection_check_handle_validity(connection)) ||
!(_connection_libnet_check_profile_validity(profile))) {
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);
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
+ return CONNECTION_ERROR_PERMISSION_DENIED;
+ } else if (rv != NET_ERR_NONE) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Failed to modify profile[%d]", rv);
return CONNECTION_ERROR_OPERATION_FAILED;
}
return CONNECTION_ERROR_NONE;
}
-int connection_get_profile_iterator(connection_h connection,
+EXPORT_API int connection_get_profile_iterator(connection_h connection,
connection_iterator_type_e type, connection_profile_iterator_h* profile_iterator)
{
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);
}
-int connection_profile_iterator_next(connection_profile_iterator_h profile_iterator,
+EXPORT_API int connection_profile_iterator_next(connection_profile_iterator_h profile_iterator,
connection_profile_h* profile)
{
return _connection_libnet_get_iterator_next(profile_iterator, profile);
}
-bool connection_profile_iterator_has_next(connection_profile_iterator_h profile_iterator)
+EXPORT_API bool connection_profile_iterator_has_next(connection_profile_iterator_h profile_iterator)
{
return _connection_libnet_iterator_has_next(profile_iterator);
}
-int connection_destroy_profile_iterator(connection_profile_iterator_h profile_iterator)
+EXPORT_API int connection_destroy_profile_iterator(connection_profile_iterator_h profile_iterator)
{
return _connection_libnet_destroy_iterator(profile_iterator);
}
-int connection_get_current_profile(connection_h connection, connection_profile_h* profile)
+EXPORT_API int connection_get_current_profile(connection_h connection, connection_profile_h* profile)
{
if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
return _connection_libnet_get_current_profile(profile);
}
-int connection_open_profile(connection_h connection, connection_profile_h profile,
- connection_opened_cb callback, void* user_data)
+EXPORT_API int connection_get_default_cellular_service_profile(connection_h connection,
+ connection_cellular_service_type_e type, connection_profile_h* profile)
{
- if (!(__connection_check_handle_validity(connection)) ||
- profile == NULL || callback == NULL) {
+ if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
- return _connection_libnet_open_profile(profile, callback, user_data);
+ return _connection_libnet_get_cellular_service_profile(type, profile);
}
-int connection_get_default_cellular_service_profile(connection_h connection,
- connection_cellular_service_type_e type, connection_profile_h* profile)
+
+EXPORT_API int connection_set_default_cellular_service_profile(connection_h connection,
+ connection_cellular_service_type_e type, connection_profile_h profile)
{
if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
- return _connection_libnet_get_cellular_service_profile(type, profile);
+ return _connection_libnet_set_cellular_service_profile_sync(type, profile);
}
-int connection_set_default_cellular_service_profile(connection_h connection,
- connection_cellular_service_type_e type, connection_profile_h 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)
{
- if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
+ if (!(__connection_check_handle_validity(connection)) ||
+ profile == NULL || callback == NULL) {
CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
return CONNECTION_ERROR_INVALID_PARAMETER;
}
- return _connection_libnet_set_cellular_service_profile(type, profile);
+ return _connection_libnet_set_cellular_service_profile_async(type, profile, callback, user_data);
}
-int connection_close_profile(connection_h connection, connection_profile_h profile,
+EXPORT_API int connection_open_profile(connection_h connection, connection_profile_h profile,
+ connection_opened_cb callback, void* user_data)
+{
+ if (!(__connection_check_handle_validity(connection)) ||
+ profile == NULL || callback == NULL) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ return _connection_libnet_open_profile(profile, callback, user_data);
+}
+
+EXPORT_API int connection_close_profile(connection_h connection, connection_profile_h profile,
connection_closed_cb callback, void* user_data)
{
if (!(__connection_check_handle_validity(connection)) ||
return _connection_libnet_close_profile(profile, callback, user_data);
}
-int connection_add_route(connection_h connection, const char* interface_name, const char* host_address)
+EXPORT_API int connection_reset_profile(connection_h connection,
+ connection_reset_option_e type, int id, connection_reset_cb callback, void *user_data)
+{
+ 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");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
+ return _connection_libnet_reset_profile(type, id, callback, user_data);
+}
+
+EXPORT_API int connection_add_route(connection_h connection, const char* interface_name, const char* host_address)
{
if (!(__connection_check_handle_validity(connection)) ||
interface_name == NULL || host_address == NULL) {
return _connection_libnet_add_route(interface_name, host_address);
}
+EXPORT_API int connection_remove_route(connection_h connection, const char* interface_name, const char* host_address)
+{
+ 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(interface_name, host_address);
+}
/* Connection Statistics module ******************************************************************/
static int __get_statistic(connection_type_e connection_type,
connection_statistics_type_e statistics_type, long long* llsize)
{
- int size;
+ int rv, size;
unsigned long long ull_size;
int stat_type;
char *key = NULL;
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);
+ rv = _connection_libnet_get_statistics(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");
*llsize = 0;
return CONNECTION_ERROR_OPERATION_FAILED;
}
return CONNECTION_ERROR_NONE;
}
-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)
{
+ if (!(__connection_check_handle_validity(connection)) || size == NULL) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
return __get_statistic(connection_type, statistics_type, size);
}
-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)
{
+ if (!(__connection_check_handle_validity(connection))) {
+ CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
+ return CONNECTION_ERROR_INVALID_PARAMETER;
+ }
+
return __reset_statistic(connection_type, statistics_type);
}
-
projects / platform / core / api / connection.git / blobdiff