2 * Copyright (c) 2011-2013 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
20 #include <vconf/vconf.h>
21 #include "net_connection_private.h"
23 static GSList *conn_handle_list = NULL;
25 static void __connection_cb_state_change_cb(keynode_t *node, void *user_data);
26 static void __connection_cb_ip_change_cb(keynode_t *node, void *user_data);
27 static void __connection_cb_proxy_change_cb(keynode_t *node, void *user_data);
29 static int __connection_convert_net_state(int status)
32 case VCONFKEY_NETWORK_CELLULAR:
33 return CONNECTION_TYPE_CELLULAR;
34 case VCONFKEY_NETWORK_WIFI:
35 return CONNECTION_TYPE_WIFI;
36 case VCONFKEY_NETWORK_ETHERNET:
37 return CONNECTION_TYPE_ETHERNET;
38 case VCONFKEY_NETWORK_BLUETOOTH:
39 return CONNECTION_TYPE_BT;
41 return CONNECTION_TYPE_DISCONNECTED;
45 static int __connection_convert_cellular_state(int status)
48 case VCONFKEY_NETWORK_CELLULAR_ON:
49 return CONNECTION_CELLULAR_STATE_AVAILABLE;
50 case VCONFKEY_NETWORK_CELLULAR_3G_OPTION_OFF:
51 return CONNECTION_CELLULAR_STATE_CALL_ONLY_AVAILABLE;
52 case VCONFKEY_NETWORK_CELLULAR_ROAMING_OFF:
53 return CONNECTION_CELLULAR_STATE_ROAMING_OFF;
54 case VCONFKEY_NETWORK_CELLULAR_FLIGHT_MODE:
55 return CONNECTION_CELLULAR_STATE_FLIGHT_MODE;
57 return CONNECTION_CELLULAR_STATE_OUT_OF_SERVICE;
61 static int __connection_get_type_changed_callback_count(void)
66 for (list = conn_handle_list; list; list = list->next) {
67 connection_handle_s *local_handle = (connection_handle_s *)list->data;
68 if (local_handle->type_changed_callback) count++;
74 static int __connection_get_ip_changed_callback_count(void)
79 for (list = conn_handle_list; list; list = list->next) {
80 connection_handle_s *local_handle = (connection_handle_s *)list->data;
81 if (local_handle->ip_changed_callback) count++;
87 static int __connection_get_proxy_changed_callback_count(void)
92 for (list = conn_handle_list; list; list = list->next) {
93 connection_handle_s *local_handle = (connection_handle_s *)list->data;
94 if (local_handle->proxy_changed_callback) count++;
100 static int __connection_set_type_changed_callback(connection_h connection,
101 void *callback, void *user_data)
103 connection_handle_s *local_handle = (connection_handle_s *)connection;
106 if (__connection_get_type_changed_callback_count() == 0)
107 if (vconf_notify_key_changed(VCONFKEY_NETWORK_STATUS ,
108 __connection_cb_state_change_cb, NULL))
109 return CONNECTION_ERROR_OPERATION_FAILED;
111 local_handle->state_changed_user_data = user_data;
113 if (local_handle->type_changed_callback &&
114 __connection_get_type_changed_callback_count() == 1)
115 if (vconf_ignore_key_changed(VCONFKEY_NETWORK_STATUS,
116 __connection_cb_state_change_cb))
117 return CONNECTION_ERROR_OPERATION_FAILED;
120 local_handle->type_changed_callback = callback;
121 return CONNECTION_ERROR_NONE;
124 static int __connection_set_ip_changed_callback(connection_h connection,
125 void *callback, void *user_data)
127 connection_handle_s *local_handle = (connection_handle_s *)connection;
130 if (__connection_get_ip_changed_callback_count() == 0)
131 if (vconf_notify_key_changed(VCONFKEY_NETWORK_IP,
132 __connection_cb_ip_change_cb, NULL))
133 return CONNECTION_ERROR_OPERATION_FAILED;
135 local_handle->ip_changed_user_data = user_data;
137 if (local_handle->ip_changed_callback &&
138 __connection_get_ip_changed_callback_count() == 1)
139 if (vconf_ignore_key_changed(VCONFKEY_NETWORK_IP,
140 __connection_cb_ip_change_cb))
141 return CONNECTION_ERROR_OPERATION_FAILED;
144 local_handle->ip_changed_callback = callback;
145 return CONNECTION_ERROR_NONE;
148 static int __connection_set_proxy_changed_callback(connection_h connection,
149 void *callback, void *user_data)
151 connection_handle_s *local_handle = (connection_handle_s *)connection;
154 if (__connection_get_proxy_changed_callback_count() == 0)
155 if (vconf_notify_key_changed(VCONFKEY_NETWORK_PROXY,
156 __connection_cb_proxy_change_cb, NULL))
157 return CONNECTION_ERROR_OPERATION_FAILED;
159 local_handle->proxy_changed_user_data = user_data;
161 if (local_handle->proxy_changed_callback &&
162 __connection_get_proxy_changed_callback_count() == 1)
163 if (vconf_ignore_key_changed(VCONFKEY_NETWORK_PROXY,
164 __connection_cb_proxy_change_cb))
165 return CONNECTION_ERROR_OPERATION_FAILED;
168 local_handle->proxy_changed_callback = callback;
169 return CONNECTION_ERROR_NONE;
172 static void __connection_cb_state_change_cb(keynode_t *node, void *user_data)
174 CONNECTION_LOG(CONNECTION_INFO, "Net Status Changed Indication\n");
177 int state = vconf_keynode_get_int(node);
179 for (list = conn_handle_list; list; list = list->next) {
180 connection_handle_s *local_handle = (connection_handle_s *)list->data;
181 if (local_handle->type_changed_callback)
182 local_handle->type_changed_callback(
183 __connection_convert_net_state(state),
184 local_handle->state_changed_user_data);
188 static void __connection_cb_ip_change_cb(keynode_t *node, void *user_data)
190 CONNECTION_LOG(CONNECTION_INFO, "Net IP Changed Indication\n");
193 char *ip_addr = vconf_keynode_get_str(node);
195 for (list = conn_handle_list; list; list = list->next) {
196 connection_handle_s *local_handle = (connection_handle_s *)list->data;
197 if (local_handle->ip_changed_callback)
198 local_handle->ip_changed_callback(
200 local_handle->ip_changed_user_data);
204 static void __connection_cb_proxy_change_cb(keynode_t *node, void *user_data)
206 CONNECTION_LOG(CONNECTION_INFO, "Net IP Changed Indication\n");
209 char *proxy = vconf_keynode_get_str(node);
211 for (list = conn_handle_list; list; list = list->next) {
212 connection_handle_s *local_handle = (connection_handle_s *)list->data;
213 if (local_handle->proxy_changed_callback)
214 local_handle->proxy_changed_callback(
216 local_handle->proxy_changed_user_data);
220 static bool __connection_check_handle_validity(connection_h connection)
224 if (connection == NULL)
227 if (g_slist_find(conn_handle_list, connection) != NULL)
233 static int __connection_get_handle_count(void)
238 if (!conn_handle_list)
241 for (list = conn_handle_list; list; list = list->next) count++;
246 /* Connection Manager ********************************************************/
247 EXPORT_API int connection_create(connection_h* connection)
249 CONNECTION_MUTEX_LOCK;
251 if (connection == NULL || __connection_check_handle_validity(*connection)) {
252 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
253 CONNECTION_MUTEX_UNLOCK;
254 return CONNECTION_ERROR_INVALID_PARAMETER;
257 rv = _connection_libnet_init();
258 if (rv == NET_ERR_ACCESS_DENIED) {
259 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
260 CONNECTION_MUTEX_UNLOCK;
261 return CONNECTION_ERROR_PERMISSION_DENIED;
263 else if (rv != NET_ERR_NONE) {
264 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create connection[%d]", rv);
265 CONNECTION_MUTEX_UNLOCK;
266 return CONNECTION_ERROR_OPERATION_FAILED;
269 *connection = g_try_malloc0(sizeof(connection_handle_s));
270 if (*connection != NULL) {
271 CONNECTION_LOG(CONNECTION_INFO, "New Handle Created %p\n", *connection);
273 CONNECTION_MUTEX_UNLOCK;
274 return CONNECTION_ERROR_OUT_OF_MEMORY;
277 conn_handle_list = g_slist_append(conn_handle_list, *connection);
279 CONNECTION_MUTEX_UNLOCK;
280 return CONNECTION_ERROR_NONE;
283 EXPORT_API int connection_destroy(connection_h connection)
285 CONNECTION_MUTEX_LOCK;
287 if (connection == NULL || !(__connection_check_handle_validity(connection))) {
288 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
289 CONNECTION_MUTEX_UNLOCK;
290 return CONNECTION_ERROR_INVALID_PARAMETER;
293 CONNECTION_LOG(CONNECTION_INFO, "Destroy Handle : %p\n", connection);
295 __connection_set_type_changed_callback(connection, NULL, NULL);
296 __connection_set_ip_changed_callback(connection, NULL, NULL);
297 __connection_set_proxy_changed_callback(connection, NULL, NULL);
299 conn_handle_list = g_slist_remove(conn_handle_list, connection);
303 if (__connection_get_handle_count() == 0)
304 _connection_libnet_deinit();
306 CONNECTION_MUTEX_UNLOCK;
307 return CONNECTION_ERROR_NONE;
310 EXPORT_API int connection_get_type(connection_h connection, connection_type_e* type)
314 if (type == NULL || !(__connection_check_handle_validity(connection))) {
315 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
316 return CONNECTION_ERROR_INVALID_PARAMETER;
319 if (vconf_get_int(VCONFKEY_NETWORK_STATUS, &status)) {
320 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed = %d\n", status);
321 return CONNECTION_ERROR_OPERATION_FAILED;
324 CONNECTION_LOG(CONNECTION_INFO, "Connected Network = %d\n", status);
326 *type = __connection_convert_net_state(status);
328 return CONNECTION_ERROR_NONE;
331 EXPORT_API int connection_get_ip_address(connection_h connection,
332 connection_address_family_e address_family, char** ip_address)
334 if (ip_address == NULL || !(__connection_check_handle_validity(connection))) {
335 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
336 return CONNECTION_ERROR_INVALID_PARAMETER;
339 switch (address_family) {
340 case CONNECTION_ADDRESS_FAMILY_IPV4:
341 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP);
343 case CONNECTION_ADDRESS_FAMILY_IPV6:
344 CONNECTION_LOG(CONNECTION_ERROR, "Not supported yet\n");
345 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
348 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
349 return CONNECTION_ERROR_INVALID_PARAMETER;
352 if (*ip_address == NULL) {
353 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed\n");
354 return CONNECTION_ERROR_OPERATION_FAILED;
357 return CONNECTION_ERROR_NONE;
360 EXPORT_API int connection_get_proxy(connection_h connection,
361 connection_address_family_e address_family, char** proxy)
363 if (proxy == NULL || !(__connection_check_handle_validity(connection))) {
364 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
365 return CONNECTION_ERROR_INVALID_PARAMETER;
368 switch (address_family) {
369 case CONNECTION_ADDRESS_FAMILY_IPV4:
370 *proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
372 case CONNECTION_ADDRESS_FAMILY_IPV6:
373 CONNECTION_LOG(CONNECTION_ERROR, "Not supported yet\n");
374 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
377 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
378 return CONNECTION_ERROR_INVALID_PARAMETER;
381 if (*proxy == NULL) {
382 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed\n");
383 return CONNECTION_ERROR_OPERATION_FAILED;
386 return CONNECTION_ERROR_NONE;
389 EXPORT_API int connection_get_cellular_state(connection_h connection, connection_cellular_state_e* state)
392 int cellular_state = 0;
394 if (state == NULL || !(__connection_check_handle_validity(connection))) {
395 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
396 return CONNECTION_ERROR_INVALID_PARAMETER;
399 if (!vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &status)) {
400 CONNECTION_LOG(CONNECTION_INFO, "Cellular = %d\n", status);
401 *state = __connection_convert_cellular_state(status);
403 if (*state == CONNECTION_CELLULAR_STATE_AVAILABLE) {
404 if (vconf_get_int(VCONFKEY_DNET_STATE, &cellular_state)) {
405 CONNECTION_LOG(CONNECTION_ERROR,
406 "vconf_get_int Failed = %d\n", cellular_state);
407 return CONNECTION_ERROR_OPERATION_FAILED;
411 CONNECTION_LOG(CONNECTION_INFO, "Connection state = %d\n", cellular_state);
413 if (cellular_state == VCONFKEY_DNET_NORMAL_CONNECTED ||
414 cellular_state == VCONFKEY_DNET_SECURE_CONNECTED ||
415 cellular_state == VCONFKEY_DNET_TRANSFER)
416 *state = CONNECTION_CELLULAR_STATE_CONNECTED;
418 return CONNECTION_ERROR_NONE;
420 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed = %d\n", status);
421 return CONNECTION_ERROR_OPERATION_FAILED;
425 EXPORT_API int connection_get_wifi_state(connection_h connection, connection_wifi_state_e* state)
429 if (state == NULL || !(__connection_check_handle_validity(connection))) {
430 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
431 return CONNECTION_ERROR_INVALID_PARAMETER;
434 rv = _connection_libnet_get_wifi_state(state);
435 if (rv != CONNECTION_ERROR_NONE) {
436 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get Wi-Fi state[%d]", rv);
440 CONNECTION_LOG(CONNECTION_INFO, "WiFi state = %d\n", *state);
442 return CONNECTION_ERROR_NONE;
445 EXPORT_API int connection_get_ethernet_state(connection_h connection, connection_ethernet_state_e* state)
447 if (state == NULL || !(__connection_check_handle_validity(connection))) {
448 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
449 return CONNECTION_ERROR_INVALID_PARAMETER;
452 return _connection_libnet_get_ethernet_state(state);
455 EXPORT_API int connection_get_bt_state(connection_h connection, connection_bt_state_e* state)
457 if (state == NULL || !(__connection_check_handle_validity(connection))) {
458 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
459 return CONNECTION_ERROR_INVALID_PARAMETER;
462 return _connection_libnet_get_bluetooth_state(state);
466 EXPORT_API int connection_set_type_changed_cb(connection_h connection,
467 connection_type_changed_cb callback, void* user_data)
469 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
470 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
471 return CONNECTION_ERROR_INVALID_PARAMETER;
474 return __connection_set_type_changed_callback(connection, callback, user_data);
477 EXPORT_API int connection_unset_type_changed_cb(connection_h connection)
479 if (!(__connection_check_handle_validity(connection))) {
480 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
481 return CONNECTION_ERROR_INVALID_PARAMETER;
484 return __connection_set_type_changed_callback(connection, NULL, NULL);
487 EXPORT_API int connection_set_ip_address_changed_cb(connection_h connection,
488 connection_address_changed_cb callback, void* user_data)
490 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
491 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
492 return CONNECTION_ERROR_INVALID_PARAMETER;
495 return __connection_set_ip_changed_callback(connection, callback, user_data);
498 EXPORT_API int connection_unset_ip_address_changed_cb(connection_h connection)
500 if (!(__connection_check_handle_validity(connection))) {
501 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
502 return CONNECTION_ERROR_INVALID_PARAMETER;
505 return __connection_set_ip_changed_callback(connection, NULL, NULL);
508 EXPORT_API int connection_set_proxy_address_changed_cb(connection_h connection,
509 connection_address_changed_cb callback, void* user_data)
511 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
512 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
513 return CONNECTION_ERROR_INVALID_PARAMETER;
516 return __connection_set_proxy_changed_callback(connection, callback, user_data);
519 EXPORT_API int connection_unset_proxy_address_changed_cb(connection_h connection)
521 if (!(__connection_check_handle_validity(connection))) {
522 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
523 return CONNECTION_ERROR_INVALID_PARAMETER;
526 return __connection_set_proxy_changed_callback(connection, NULL, NULL);
529 EXPORT_API int connection_add_profile(connection_h connection, connection_profile_h profile)
531 if (!(__connection_check_handle_validity(connection)) ||
532 !(_connection_libnet_check_profile_validity(profile))) {
533 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
534 return CONNECTION_ERROR_INVALID_PARAMETER;
539 net_profile_info_t *profile_info = profile;
541 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
542 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
543 return CONNECTION_ERROR_INVALID_PARAMETER;
546 rv = net_add_profile(profile_info->ProfileInfo.Pdp.ServiceType, (net_profile_info_t*)profile);
547 if (rv == NET_ERR_ACCESS_DENIED) {
548 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
549 return CONNECTION_ERROR_PERMISSION_DENIED;
550 } else if (rv != NET_ERR_NONE) {
551 CONNECTION_LOG(CONNECTION_ERROR, "Failed to add profile[%d]", rv);
552 return CONNECTION_ERROR_OPERATION_FAILED;
555 return CONNECTION_ERROR_NONE;
558 EXPORT_API int connection_remove_profile(connection_h connection, connection_profile_h profile)
560 if (!(__connection_check_handle_validity(connection)) ||
561 !(_connection_libnet_check_profile_validity(profile))) {
562 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
563 return CONNECTION_ERROR_INVALID_PARAMETER;
567 net_profile_info_t *profile_info = profile;
569 if (profile_info->profile_type != NET_DEVICE_CELLULAR &&
570 profile_info->profile_type != NET_DEVICE_WIFI) {
571 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
572 return CONNECTION_ERROR_INVALID_PARAMETER;
575 rv = net_delete_profile(profile_info->ProfileName);
576 if (rv == NET_ERR_ACCESS_DENIED) {
577 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
578 return CONNECTION_ERROR_PERMISSION_DENIED;
579 } else if (rv != NET_ERR_NONE) {
580 CONNECTION_LOG(CONNECTION_ERROR, "Failed to delete profile[%d]", rv);
581 return CONNECTION_ERROR_OPERATION_FAILED;
584 return CONNECTION_ERROR_NONE;
587 EXPORT_API int connection_update_profile(connection_h connection, connection_profile_h profile)
589 if (!(__connection_check_handle_validity(connection)) ||
590 !(_connection_libnet_check_profile_validity(profile))) {
591 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
592 return CONNECTION_ERROR_INVALID_PARAMETER;
596 net_profile_info_t *profile_info = profile;
598 rv = net_modify_profile(profile_info->ProfileName, (net_profile_info_t*)profile);
599 if (rv == NET_ERR_ACCESS_DENIED) {
600 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
601 return CONNECTION_ERROR_PERMISSION_DENIED;
602 } else if (rv != NET_ERR_NONE) {
603 CONNECTION_LOG(CONNECTION_ERROR, "Failed to modify profile[%d]", rv);
604 return CONNECTION_ERROR_OPERATION_FAILED;
607 return CONNECTION_ERROR_NONE;
610 EXPORT_API int connection_get_profile_iterator(connection_h connection,
611 connection_iterator_type_e type, connection_profile_iterator_h* profile_iterator)
613 if (!(__connection_check_handle_validity(connection)) ||
614 (type != CONNECTION_ITERATOR_TYPE_REGISTERED &&
615 type != CONNECTION_ITERATOR_TYPE_CONNECTED &&
616 type != CONNECTION_ITERATOR_TYPE_DEFAULT)) {
617 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
618 return CONNECTION_ERROR_INVALID_PARAMETER;
621 return _connection_libnet_get_profile_iterator(type, profile_iterator);
624 EXPORT_API int connection_profile_iterator_next(connection_profile_iterator_h profile_iterator,
625 connection_profile_h* profile)
627 return _connection_libnet_get_iterator_next(profile_iterator, profile);
630 EXPORT_API bool connection_profile_iterator_has_next(connection_profile_iterator_h profile_iterator)
632 return _connection_libnet_iterator_has_next(profile_iterator);
635 EXPORT_API int connection_destroy_profile_iterator(connection_profile_iterator_h profile_iterator)
637 return _connection_libnet_destroy_iterator(profile_iterator);
640 EXPORT_API int connection_get_current_profile(connection_h connection, connection_profile_h* profile)
642 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
643 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
644 return CONNECTION_ERROR_INVALID_PARAMETER;
647 return _connection_libnet_get_current_profile(profile);
650 EXPORT_API int connection_get_default_cellular_service_profile(connection_h connection,
651 connection_cellular_service_type_e type, connection_profile_h* profile)
653 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
654 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
655 return CONNECTION_ERROR_INVALID_PARAMETER;
658 return _connection_libnet_get_cellular_service_profile(type, profile);
661 EXPORT_API int connection_set_default_cellular_service_profile(connection_h connection,
662 connection_cellular_service_type_e type, connection_profile_h profile)
664 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
665 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
666 return CONNECTION_ERROR_INVALID_PARAMETER;
669 return _connection_libnet_set_cellular_service_profile_sync(type, profile);
672 EXPORT_API int connection_set_default_cellular_service_profile_async(connection_h connection,
673 connection_cellular_service_type_e type, connection_profile_h profile,
674 connection_set_default_cb callback, void* user_data)
676 if (!(__connection_check_handle_validity(connection)) ||
677 profile == NULL || callback == NULL) {
678 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
679 return CONNECTION_ERROR_INVALID_PARAMETER;
682 return _connection_libnet_set_cellular_service_profile_async(type, profile, callback, user_data);
685 EXPORT_API int connection_open_profile(connection_h connection, connection_profile_h profile,
686 connection_opened_cb callback, void* user_data)
688 if (!(__connection_check_handle_validity(connection)) ||
689 profile == NULL || callback == NULL) {
690 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
691 return CONNECTION_ERROR_INVALID_PARAMETER;
694 return _connection_libnet_open_profile(profile, callback, user_data);
697 EXPORT_API int connection_close_profile(connection_h connection, connection_profile_h profile,
698 connection_closed_cb callback, void* user_data)
700 if (!(__connection_check_handle_validity(connection)) ||
701 profile == NULL || callback == NULL) {
702 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
703 return CONNECTION_ERROR_INVALID_PARAMETER;
706 return _connection_libnet_close_profile(profile, callback, user_data);
709 EXPORT_API int connection_reset_profile(connection_h connection,
710 connection_reset_option_e type, int id, connection_reset_cb callback, void *user_data)
712 if (!(__connection_check_handle_validity(connection))) {
713 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
714 return CONNECTION_ERROR_INVALID_PARAMETER;
717 if(id < 0 || id > 1) {
718 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
719 return CONNECTION_ERROR_INVALID_PARAMETER;
722 return _connection_libnet_reset_profile(type, id, callback, user_data);
725 EXPORT_API int connection_add_route(connection_h connection, const char* interface_name, const char* host_address)
727 if (!(__connection_check_handle_validity(connection)) ||
728 interface_name == NULL || host_address == NULL) {
729 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
730 return CONNECTION_ERROR_INVALID_PARAMETER;
733 return _connection_libnet_add_route(interface_name, host_address);
736 EXPORT_API int connection_remove_route(connection_h connection, const char* interface_name, const char* host_address)
738 if (!(__connection_check_handle_validity(connection)) ||
739 interface_name == NULL || host_address == NULL) {
740 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
741 return CONNECTION_ERROR_INVALID_PARAMETER;
744 return _connection_libnet_remove_route(interface_name, host_address);
747 /* Connection Statistics module ******************************************************************/
749 static int __get_statistic(connection_type_e connection_type,
750 connection_statistics_type_e statistics_type, long long* llsize)
753 unsigned long long ull_size;
757 if (llsize == NULL) {
758 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
759 return CONNECTION_ERROR_INVALID_PARAMETER;
762 if (connection_type == CONNECTION_TYPE_CELLULAR) {
763 switch (statistics_type) {
764 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
765 key = VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT;
767 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
768 key = VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV;
770 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
771 key = VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT;
773 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
774 key = VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV;
777 return CONNECTION_ERROR_INVALID_PARAMETER;
780 if (vconf_get_int(key, &size)) {
781 CONNECTION_LOG(CONNECTION_ERROR, "Cannot Get %s = %d\n", key, size);
783 return CONNECTION_ERROR_OPERATION_FAILED;
786 CONNECTION_LOG(CONNECTION_INFO,"%s:%d bytes\n", key, size);
787 *llsize = (long long)size;
788 } else if (connection_type == CONNECTION_TYPE_WIFI) {
789 switch (statistics_type) {
790 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
791 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
793 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
794 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
796 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
797 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
799 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
800 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
803 return CONNECTION_ERROR_INVALID_PARAMETER;
806 rv = _connection_libnet_get_statistics(stat_type, &ull_size);
807 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
809 else if (rv != CONNECTION_ERROR_NONE) {
810 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get Wi-Fi statistics");
812 return CONNECTION_ERROR_OPERATION_FAILED;
815 CONNECTION_LOG(CONNECTION_INFO,"%d bytes\n", ull_size);
816 *llsize = (long long)ull_size;
818 return CONNECTION_ERROR_INVALID_PARAMETER;
820 return CONNECTION_ERROR_NONE;
823 static int __reset_statistic(connection_type_e connection_type,
824 connection_statistics_type_e statistics_type)
830 if (connection_type == CONNECTION_TYPE_CELLULAR)
831 conn_type = NET_DEVICE_CELLULAR;
832 else if (connection_type == CONNECTION_TYPE_WIFI)
833 conn_type = NET_DEVICE_WIFI;
835 return CONNECTION_ERROR_INVALID_PARAMETER;
837 switch (statistics_type) {
838 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
839 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
841 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
842 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
844 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
845 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
847 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
848 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
851 return CONNECTION_ERROR_INVALID_PARAMETER;
854 rv = _connection_libnet_set_statistics(conn_type, stat_type);
855 if(rv != CONNECTION_ERROR_NONE)
859 CONNECTION_LOG(CONNECTION_INFO,"connection_reset_statistics success\n");
861 return CONNECTION_ERROR_NONE;
864 EXPORT_API int connection_get_statistics(connection_h connection,
865 connection_type_e connection_type,
866 connection_statistics_type_e statistics_type, long long* size)
868 if (!(__connection_check_handle_validity(connection)) || size == NULL) {
869 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
870 return CONNECTION_ERROR_INVALID_PARAMETER;
873 return __get_statistic(connection_type, statistics_type, size);
876 EXPORT_API int connection_reset_statistics(connection_h connection,
877 connection_type_e connection_type,
878 connection_statistics_type_e statistics_type)
880 if (!(__connection_check_handle_validity(connection))) {
881 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
882 return CONNECTION_ERROR_INVALID_PARAMETER;
885 return __reset_statistic(connection_type, statistics_type);