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.
21 #include <vconf/vconf.h>
22 #include <system_info.h>
24 #include "net_connection_private.h"
26 static GSList *conn_handle_list = NULL;
27 static int tv_profile = -1; // Unknown
30 static int __connection_convert_net_state(int status)
33 case VCONFKEY_NETWORK_CELLULAR:
34 return CONNECTION_TYPE_CELLULAR;
35 case VCONFKEY_NETWORK_WIFI:
36 return CONNECTION_TYPE_WIFI;
37 case VCONFKEY_NETWORK_ETHERNET:
38 return CONNECTION_TYPE_ETHERNET;
39 case VCONFKEY_NETWORK_BLUETOOTH:
40 return CONNECTION_TYPE_BT;
41 case VCONFKEY_NETWORK_DEFAULT_PROXY:
42 return CONNECTION_TYPE_NET_PROXY;
44 return CONNECTION_TYPE_DISCONNECTED;
48 static int __connection_convert_cellular_state(int status)
51 case VCONFKEY_NETWORK_CELLULAR_ON:
52 return CONNECTION_CELLULAR_STATE_AVAILABLE;
53 case VCONFKEY_NETWORK_CELLULAR_3G_OPTION_OFF:
54 return CONNECTION_CELLULAR_STATE_CALL_ONLY_AVAILABLE;
55 case VCONFKEY_NETWORK_CELLULAR_ROAMING_OFF:
56 return CONNECTION_CELLULAR_STATE_ROAMING_OFF;
57 case VCONFKEY_NETWORK_CELLULAR_FLIGHT_MODE:
58 return CONNECTION_CELLULAR_STATE_FLIGHT_MODE;
60 return CONNECTION_CELLULAR_STATE_OUT_OF_SERVICE;
64 static bool __connection_check_handle_validity(connection_h connection)
68 if (connection == NULL)
71 if (g_slist_find(conn_handle_list, connection) != NULL)
77 bool _connection_check_handle_validity(connection_h connection)
79 return __connection_check_handle_validity(connection);
82 static void __connection_set_type_changed_callback(connection_handle_s *conn_handle,
83 void *callback, void *user_data)
85 conn_handle->type_changed_user_data = user_data;
86 conn_handle->type_changed_callback = callback;
89 static void __connection_set_ip_changed_callback(connection_handle_s *conn_handle,
90 void *callback, void *user_data)
92 conn_handle->ip_changed_user_data = user_data;
93 conn_handle->ip_changed_callback = callback;
96 static void __connection_set_proxy_changed_callback(connection_handle_s *conn_handle,
97 void *callback, void *user_data)
99 conn_handle->proxy_changed_user_data = user_data;
100 conn_handle->proxy_changed_callback = callback;
103 static void __connection_set_internet_state_changed_callback(connection_handle_s *conn_handle,
104 void *callback, void *user_data)
106 conn_handle->internet_state_changed_user_data = user_data;
107 conn_handle->internet_state_changed_callback = callback;
110 static void __connection_set_ethernet_cable_state_changed_cb(connection_handle_s *conn_handle,
111 void *callback, void *user_data)
113 conn_handle->ethernet_cable_state_changed_callback = callback;
114 conn_handle->ethernet_cable_state_changed_user_data = user_data;
117 static void __connection_set_default_cellular_service_profile_callback(connection_handle_s *conn_handle,
118 void *callback, void *user_data)
120 conn_handle->set_default_callback = callback;
121 conn_handle->set_default_user_data = user_data;
124 static void __connection_open_profile_set_callback(connection_handle_s *conn_handle,
125 void *callback, void *user_data)
127 conn_handle->opened_callback = callback;
128 conn_handle->opened_user_data = user_data;
131 static void __connection_close_profile_set_callback(connection_handle_s *conn_handle,
132 void *callback, void *user_data)
134 conn_handle->closed_callback = callback;
135 conn_handle->closed_user_data = user_data;
138 static void __connection_reset_profile_set_callback(connection_handle_s *conn_handle,
139 void *callback, void *user_data)
141 conn_handle->reset_callback = callback;
142 conn_handle->reset_user_data = user_data;
146 /* Connection Manager ********************************************************/
147 EXPORT_API int connection_create(connection_h *connection)
151 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
155 if (connection == NULL || __connection_check_handle_validity(*connection)) {
156 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
157 CONN_UNLOCK; //LCOV_EXCL_LINE
158 return CONNECTION_ERROR_INVALID_PARAMETER;
161 *connection = g_try_malloc0(sizeof(connection_handle_s));
162 if (*connection != NULL) {
163 CONNECTION_LOG(CONNECTION_INFO, "New handle created[%p]", *connection);
165 CONN_UNLOCK; //LCOV_EXCL_LINE
166 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
169 rv = _connection_libnet_init(*connection);
170 if (rv == NET_ERR_ACCESS_DENIED) {
171 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
172 CONN_UNLOCK; //LCOV_EXCL_LINE
173 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
174 } else if (rv != NET_ERR_NONE) {
175 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create connection[%d]", rv); //LCOV_EXCL_LINE
176 CONN_UNLOCK; //LCOV_EXCL_LINE
177 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
180 conn_handle_list = g_slist_prepend(conn_handle_list, *connection);
183 return CONNECTION_ERROR_NONE;
186 EXPORT_API int connection_destroy(connection_h connection)
190 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
192 if (!(__connection_check_handle_validity(connection))) {
193 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
195 return CONNECTION_ERROR_INVALID_PARAMETER;
198 CONNECTION_LOG(CONNECTION_INFO, "Destroy handle: %p", connection);
200 __connection_set_type_changed_callback(connection, NULL, NULL);
201 __connection_set_ip_changed_callback(connection, NULL, NULL);
202 __connection_set_proxy_changed_callback(connection, NULL, NULL);
203 __connection_set_internet_state_changed_callback(connection, NULL, NULL);
204 __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
206 conn_handle_list = g_slist_remove(conn_handle_list, connection);
207 _connection_libnet_deinit(connection, (conn_handle_list == NULL));
213 return CONNECTION_ERROR_NONE;
217 EXPORT_API int connection_create_cs(int tid, connection_h *connection)
221 rv = connection_create(connection);
222 if (rv == CONNECTION_ERROR_NONE) {
224 _connection_set_cs_tid(tid, *connection);
231 EXPORT_API int connection_destroy_cs(int tid, connection_h connection)
237 if (!(__connection_check_handle_validity(connection))) {
238 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
240 return CONNECTION_ERROR_INVALID_PARAMETER;
243 CONNECTION_LOG(CONNECTION_INFO, "Destroy connection handle: %p", connection);
244 _connection_unset_cs_tid(tid, connection);
247 rv = connection_destroy(connection);
253 EXPORT_API int connection_get_type(connection_h connection, connection_type_e* type)
260 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
262 if (type == NULL || !(__connection_check_handle_validity(connection))) {
263 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
265 return CONNECTION_ERROR_INVALID_PARAMETER;
268 rv = vconf_get_int(VCONFKEY_NETWORK_STATUS, &status);
269 if (rv != VCONF_OK) {
270 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed = %d", status); //LCOV_EXCL_LINE
271 CONN_UNLOCK; //LCOV_EXCL_LINE
272 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
275 CONNECTION_LOG(CONNECTION_INFO, "Connected Network = %d", status);
277 *type = __connection_convert_net_state(status);
280 return CONNECTION_ERROR_NONE;
283 EXPORT_API int connection_get_ip_address(connection_h connection,
284 connection_address_family_e address_family, char** ip_address)
288 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
290 if (ip_address == NULL || !(__connection_check_handle_validity(connection))) {
291 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
293 return CONNECTION_ERROR_INVALID_PARAMETER;
296 switch (address_family) {
297 case CONNECTION_ADDRESS_FAMILY_IPV4:
298 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP);
300 case CONNECTION_ADDRESS_FAMILY_IPV6:
301 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP6);
304 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
306 return CONNECTION_ERROR_INVALID_PARAMETER;
309 if (*ip_address == NULL) {
310 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
311 CONN_UNLOCK; //LCOV_EXCL_LINE
312 return CONNECTION_ERROR_OPERATION_FAILED;//LCOV_EXCL_LINE
316 return CONNECTION_ERROR_NONE;
319 EXPORT_API int connection_get_proxy(connection_h connection,
320 connection_address_family_e address_family, char** proxy)
324 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
326 if (proxy == NULL || !(__connection_check_handle_validity(connection))) {
327 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
329 return CONNECTION_ERROR_INVALID_PARAMETER;
332 switch (address_family) {
333 case CONNECTION_ADDRESS_FAMILY_IPV4:
334 case CONNECTION_ADDRESS_FAMILY_IPV6:
335 *proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
338 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
340 return CONNECTION_ERROR_INVALID_PARAMETER;
343 if (*proxy == NULL) {
344 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
345 CONN_UNLOCK; //LCOV_EXCL_LINE
346 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
350 return CONNECTION_ERROR_NONE;
353 EXPORT_API int connection_get_mac_address(connection_h connection, connection_type_e type, char** mac_addr)
356 char buf[CONNECTION_MAC_INFO_LENGTH + 1];
360 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE, ETHERNET_FEATURE);
362 if (type == CONNECTION_TYPE_WIFI)
363 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
364 else if (type == CONNECTION_TYPE_ETHERNET) //LCOV_EXCL_LINE
365 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE); //LCOV_EXCL_LINE
367 if (mac_addr == NULL || !(__connection_check_handle_validity(connection))) {
368 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
370 return CONNECTION_ERROR_INVALID_PARAMETER;
374 case CONNECTION_TYPE_WIFI:
375 if (__builtin_expect(tv_profile == -1, 0)) {
377 system_info_get_platform_string("http://tizen.org/feature/profile", &profileName);
378 if (*profileName == 't' || *profileName == 'T')
379 tv_profile = 1; //LCOV_EXCL_LINE
384 if (tv_profile == 1) {
386 fp = fopen(WIFI_MAC_INFO_FILE, "r");
388 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", WIFI_MAC_INFO_FILE);
390 return CONNECTION_ERROR_OUT_OF_MEMORY;
393 if (fgets(buf, sizeof(buf), fp) == NULL) {
394 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", WIFI_MAC_INFO_FILE);
397 return CONNECTION_ERROR_OPERATION_FAILED;
400 CONNECTION_LOG(CONNECTION_INFO, "%s : %s", WIFI_MAC_INFO_FILE, buf);
402 *mac_addr = (char *)malloc(CONNECTION_MAC_INFO_LENGTH + 1);
403 if (*mac_addr == NULL) {
404 CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed");
407 return CONNECTION_ERROR_OUT_OF_MEMORY;
409 g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1);
413 *mac_addr = vconf_get_str(VCONFKEY_WIFI_BSSID_ADDRESS);
415 if (*mac_addr == NULL) {
416 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get vconf from %s", VCONFKEY_WIFI_BSSID_ADDRESS); //LCOV_EXCL_LINE
417 CONN_UNLOCK; //LCOV_EXCL_LINE
418 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
423 case CONNECTION_TYPE_ETHERNET:
424 fp = fopen(ETHERNET_MAC_INFO_FILE, "r");
426 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", ETHERNET_MAC_INFO_FILE);
428 return CONNECTION_ERROR_OUT_OF_MEMORY;
431 if (fgets(buf, sizeof(buf), fp) == NULL) {
432 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", ETHERNET_MAC_INFO_FILE);
435 return CONNECTION_ERROR_OPERATION_FAILED;
438 CONNECTION_LOG(CONNECTION_INFO, "%s : %s", ETHERNET_MAC_INFO_FILE, buf);
440 *mac_addr = (char *)malloc(CONNECTION_MAC_INFO_LENGTH + 1);
441 if (*mac_addr == NULL) {
442 CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed");
445 return CONNECTION_ERROR_OUT_OF_MEMORY;
448 g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1);
454 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
455 CONN_UNLOCK; //LCOV_EXCL_LINE
456 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
459 /* Checking Invalid MAC Address */
460 if ((strcmp(*mac_addr, "00:00:00:00:00:00") == 0) ||
461 (strcmp(*mac_addr, "ff:ff:ff:ff:ff:ff") == 0)) {
462 CONNECTION_LOG(CONNECTION_ERROR, "MAC Address(%s) is invalid", *mac_addr); //LCOV_EXCL_LINE
463 CONN_UNLOCK; //LCOV_EXCL_LINE
464 return CONNECTION_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
467 CONNECTION_LOG(CONNECTION_INFO, "MAC Address %s", *mac_addr);
470 return CONNECTION_ERROR_NONE;
474 EXPORT_API int connection_is_metered_network(connection_h connection, bool* is_metered)
478 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
480 if (is_metered == NULL || !(__connection_check_handle_validity(connection))) {
481 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
483 return CONNECTION_ERROR_INVALID_PARAMETER;
486 int rv = _connection_libnet_get_metered_state(connection, is_metered);
487 if (rv != CONNECTION_ERROR_NONE) {
488 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get metered state[%d]", rv); //LCOV_EXCL_LINE
489 CONN_UNLOCK; //LCOV_EXCL_LINE
490 return rv; //LCOV_EXCL_LINE
493 CONNECTION_LOG(CONNECTION_INFO, "metered state: %s", is_metered ? "true" : "false");
495 return CONNECTION_ERROR_NONE;
499 EXPORT_API int connection_get_cellular_state(connection_h connection, connection_cellular_state_e* state)
503 int cellular_state = 0;
504 #if defined TIZEN_DUALSIM_ENABLE
510 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
512 if (state == NULL || !(__connection_check_handle_validity(connection))) {
513 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
515 return CONNECTION_ERROR_INVALID_PARAMETER;
518 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &status);
519 if (rv != VCONF_OK) {
520 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
521 CONN_UNLOCK; //LCOV_EXCL_LINE
522 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
525 CONNECTION_LOG(CONNECTION_INFO, "Cellular: %d", status);
526 *state = __connection_convert_cellular_state(status);
528 if (*state == CONNECTION_CELLULAR_STATE_AVAILABLE) {
529 #if defined TIZEN_DUALSIM_ENABLE
530 rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
531 if (rv != VCONF_OK) {
532 CONNECTION_LOG(CONNECTION_ERROR,
533 "Failed to get default subscriber id", sim_id);
535 return CONNECTION_ERROR_OPERATION_FAILED;
539 case CONNECTION_CELLULAR_SUBSCRIBER_1:
541 rv = vconf_get_int(VCONFKEY_DNET_STATE, &cellular_state);
542 #if defined TIZEN_DUALSIM_ENABLE
545 case CONNECTION_CELLULAR_SUBSCRIBER_2:
546 rv = vconf_get_int(VCONFKEY_DNET_STATE2, &cellular_state);
550 CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
552 return CONNECTION_ERROR_OPERATION_FAILED;
555 if (rv != VCONF_OK) {
556 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
557 CONN_UNLOCK; //LCOV_EXCL_LINE
558 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
562 CONNECTION_LOG(CONNECTION_INFO, "Cellular state: %d", cellular_state);
564 if (cellular_state == VCONFKEY_DNET_NORMAL_CONNECTED ||
565 cellular_state == VCONFKEY_DNET_SECURE_CONNECTED ||
566 cellular_state == VCONFKEY_DNET_TRANSFER)
567 *state = CONNECTION_CELLULAR_STATE_CONNECTED;
570 return CONNECTION_ERROR_NONE;
573 EXPORT_API int connection_get_wifi_state(connection_h connection, connection_wifi_state_e* state)
577 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
579 if (state == NULL || !(__connection_check_handle_validity(connection))) {
580 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
582 return CONNECTION_ERROR_INVALID_PARAMETER;
585 int rv = _connection_libnet_get_wifi_state(connection, state);
586 if (rv != CONNECTION_ERROR_NONE) {
587 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get Wi-Fi state[%d]", rv); //LCOV_EXCL_LINE
588 CONN_UNLOCK; //LCOV_EXCL_LINE
589 return rv; //LCOV_EXCL_LINE
592 CONNECTION_LOG(CONNECTION_INFO, "Wi-Fi state: %d", *state);
595 return CONNECTION_ERROR_NONE;
598 EXPORT_API int connection_get_ethernet_state(connection_h connection, connection_ethernet_state_e *state)
602 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
604 if (state == NULL || !(__connection_check_handle_validity(connection))) {
605 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
607 return CONNECTION_ERROR_INVALID_PARAMETER;
610 int rv = _connection_libnet_get_ethernet_state(connection, state);
611 if (rv != CONNECTION_ERROR_NONE) {
612 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get ethernet state[%d]", rv); //LCOV_EXCL_LINE
613 CONN_UNLOCK; //LCOV_EXCL_LINE
614 return rv; //LCOV_EXCL_LINE
618 return CONNECTION_ERROR_NONE;
621 EXPORT_API int connection_get_ethernet_cable_state(connection_h connection, connection_ethernet_cable_state_e *state)
625 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
627 if (state == NULL || !(__connection_check_handle_validity(connection))) {
628 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
630 return CONNECTION_ERROR_INVALID_PARAMETER;
633 int rv = _connection_libnet_get_ethernet_cable_state(connection, state);
634 if (rv != CONNECTION_ERROR_NONE) {
635 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get ethernet cable state[%d]", rv); //LCOV_EXCL_LINE
636 CONN_UNLOCK; //LCOV_EXCL_LINE
637 return rv; //LCOV_EXCL_LINE
641 return CONNECTION_ERROR_NONE;
644 EXPORT_API int connection_set_ethernet_cable_state_chaged_cb(connection_h connection,
645 connection_ethernet_cable_state_chaged_cb callback, void *user_data)
647 DEPRECATED_LOG(__FUNCTION__, "connection_set_ethernet_cable_state_changed_cb");
651 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
653 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
654 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
656 return CONNECTION_ERROR_INVALID_PARAMETER;
659 DEPRECATED_LOG("connection_ethernet_cable_state_chaged_cb",
660 "connection_ethernet_cable_state_changed_cb");
662 __connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data);
665 return CONNECTION_ERROR_NONE;
668 EXPORT_API int connection_unset_ethernet_cable_state_chaged_cb(connection_h connection)
670 DEPRECATED_LOG(__FUNCTION__, "connection_unset_ethernet_cable_state_changed_cb");
674 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
676 if (!(__connection_check_handle_validity(connection))) {
677 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
679 return CONNECTION_ERROR_INVALID_PARAMETER;
682 __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
685 return CONNECTION_ERROR_NONE;
688 EXPORT_API int connection_set_ethernet_cable_state_changed_cb(connection_h connection,
689 connection_ethernet_cable_state_changed_cb callback, void *user_data)
693 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
695 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
696 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
698 return CONNECTION_ERROR_INVALID_PARAMETER;
701 __connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data);
704 return CONNECTION_ERROR_NONE;
707 EXPORT_API int connection_unset_ethernet_cable_state_changed_cb(connection_h connection)
711 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
713 if (!(__connection_check_handle_validity(connection))) {
714 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
716 return CONNECTION_ERROR_INVALID_PARAMETER;
719 __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
722 return CONNECTION_ERROR_NONE;
725 EXPORT_API int connection_get_bt_state(connection_h connection, connection_bt_state_e *state)
729 CHECK_FEATURE_SUPPORTED(TETHERING_BLUETOOTH_FEATURE);
731 if (state == NULL || !(__connection_check_handle_validity(connection))) {
732 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
734 return CONNECTION_ERROR_INVALID_PARAMETER;
737 int rv = _connection_libnet_get_bluetooth_state(connection, state);
738 if (rv != CONNECTION_ERROR_NONE) {
739 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get bluetooth state[%d]", rv); //LCOV_EXCL_LINE
740 CONN_UNLOCK; //LCOV_EXCL_LINE
741 return rv; //LCOV_EXCL_LINE
745 return CONNECTION_ERROR_NONE;
748 EXPORT_API int connection_set_type_changed_cb(connection_h connection,
749 connection_type_changed_cb callback, void* user_data)
753 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
755 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
756 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
758 return CONNECTION_ERROR_INVALID_PARAMETER;
761 __connection_set_type_changed_callback(connection, callback, user_data);
764 return CONNECTION_ERROR_NONE;
767 EXPORT_API int connection_unset_type_changed_cb(connection_h connection)
771 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
773 if (!(__connection_check_handle_validity(connection))) {
774 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
776 return CONNECTION_ERROR_INVALID_PARAMETER;
779 __connection_set_type_changed_callback(connection, NULL, NULL);
782 return CONNECTION_ERROR_NONE;
785 EXPORT_API int connection_set_ip_address_changed_cb(connection_h connection,
786 connection_address_changed_cb callback, void* user_data)
790 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
792 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
793 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
795 return CONNECTION_ERROR_INVALID_PARAMETER;
798 __connection_set_ip_changed_callback(connection, callback, user_data);
801 return CONNECTION_ERROR_NONE;
804 EXPORT_API int connection_unset_ip_address_changed_cb(connection_h connection)
808 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
810 if (!(__connection_check_handle_validity(connection))) {
811 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
813 return CONNECTION_ERROR_INVALID_PARAMETER;
816 __connection_set_ip_changed_callback(connection, NULL, NULL);
819 return CONNECTION_ERROR_NONE;
822 EXPORT_API int connection_set_proxy_address_changed_cb(connection_h connection,
823 connection_address_changed_cb callback, void* user_data)
827 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
829 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
830 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
832 return CONNECTION_ERROR_INVALID_PARAMETER;
835 __connection_set_proxy_changed_callback(connection, callback, user_data);
838 return CONNECTION_ERROR_NONE;
841 EXPORT_API int connection_unset_proxy_address_changed_cb(connection_h connection)
845 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
847 if (!(__connection_check_handle_validity(connection))) {
848 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
850 return CONNECTION_ERROR_INVALID_PARAMETER;
853 __connection_set_proxy_changed_callback(connection, NULL, NULL);
856 return CONNECTION_ERROR_NONE;
859 EXPORT_API int connection_set_internet_state_changed_cb(connection_h connection,
860 connection_internet_state_changed_cb callback, void *user_data)
864 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
866 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
867 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
869 return CONNECTION_ERROR_INVALID_PARAMETER;
872 __connection_set_internet_state_changed_callback(connection, callback, user_data);
875 return CONNECTION_ERROR_NONE;
878 EXPORT_API int connection_unset_internet_state_changed_cb(connection_h connection)
882 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
884 if (!(__connection_check_handle_validity(connection))) {
885 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
887 return CONNECTION_ERROR_INVALID_PARAMETER;
890 __connection_set_internet_state_changed_callback(connection, NULL, NULL);
893 return CONNECTION_ERROR_NONE;
896 EXPORT_API int connection_add_profile(connection_h connection, connection_profile_h profile)
899 connection_handle_s *conn_handle = (connection_handle_s *)connection;
900 net_profile_info_t *profile_info = (net_profile_info_t *)profile;
904 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
906 if (!(__connection_check_handle_validity(connection)) ||
907 !(_connection_libnet_check_profile_validity(profile))) {
908 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
910 return CONNECTION_ERROR_INVALID_PARAMETER;
913 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
914 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
915 CONN_UNLOCK; //LCOV_EXCL_LINE
916 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
919 if (profile_info->ProfileInfo.Pdp.PSModemPath[0] != '/' ||
920 strlen(profile_info->ProfileInfo.Pdp.PSModemPath) < 2) {
921 CONNECTION_LOG(CONNECTION_ERROR, "Modem object path is NULL"); //LCOV_EXCL_LINE
922 CONN_UNLOCK; //LCOV_EXCL_LINE
923 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
926 rv = net_add_profile(conn_handle->network_info_handle,
927 profile_info->ProfileInfo.Pdp.ServiceType, profile_info);
928 if (rv == NET_ERR_ACCESS_DENIED) {
929 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
930 CONN_UNLOCK; //LCOV_EXCL_LINE
931 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
932 } else if (rv != NET_ERR_NONE) {
933 CONNECTION_LOG(CONNECTION_ERROR, "Failed to add profile[%d]", rv); //LCOV_EXCL_LINE
934 CONN_UNLOCK; //LCOV_EXCL_LINE
935 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
939 return CONNECTION_ERROR_NONE;
942 EXPORT_API int connection_remove_profile(connection_h connection, connection_profile_h profile)
945 connection_handle_s *conn_handle = (connection_handle_s *)connection;
946 net_profile_info_t *profile_info = (net_profile_info_t *)profile;
950 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
952 if (!(__connection_check_handle_validity(connection)) ||
953 !(_connection_libnet_check_profile_validity(profile))) {
954 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
956 return CONNECTION_ERROR_INVALID_PARAMETER;
959 if (profile_info->profile_type != NET_DEVICE_CELLULAR &&
960 profile_info->profile_type != NET_DEVICE_MESH &&
961 profile_info->profile_type != NET_DEVICE_WIFI) {
962 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
963 CONN_UNLOCK; //LCOV_EXCL_LINE
964 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
967 rv = net_delete_profile(conn_handle->network_info_handle, profile_info->ProfileName);
968 if (rv == NET_ERR_ACCESS_DENIED) {
969 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
970 CONN_UNLOCK; //LCOV_EXCL_LINE
971 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
972 } else if (rv != NET_ERR_NONE) {
973 CONNECTION_LOG(CONNECTION_ERROR, "Failed to delete profile[%d]", rv); //LCOV_EXCL_LINE
974 CONN_UNLOCK; //LCOV_EXCL_LINE
975 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
979 return CONNECTION_ERROR_NONE;
982 EXPORT_API int connection_update_profile(connection_h connection, connection_profile_h profile)
985 connection_handle_s *conn_handle = (connection_handle_s *)connection;
986 net_profile_info_t *profile_info = (net_profile_info_t *)profile;
990 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
992 if (!(__connection_check_handle_validity(connection)) ||
993 !(_connection_libnet_check_profile_validity(profile))) {
994 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
996 return CONNECTION_ERROR_INVALID_PARAMETER;
999 rv = net_modify_profile(conn_handle->network_info_handle,
1000 profile_info->ProfileName, (net_profile_info_t*)profile);
1001 if (rv == NET_ERR_ACCESS_DENIED) {
1002 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1003 CONN_UNLOCK; //LCOV_EXCL_LINE
1004 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1005 } else if (rv != NET_ERR_NONE) {
1006 CONNECTION_LOG(CONNECTION_ERROR, "Failed to modify profile[%d]", rv); //LCOV_EXCL_LINE
1007 CONN_UNLOCK; //LCOV_EXCL_LINE
1008 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1012 return CONNECTION_ERROR_NONE;
1015 EXPORT_API int connection_get_profile_iterator(connection_h connection,
1016 connection_iterator_type_e type, connection_profile_iterator_h* profile_iterator)
1020 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1022 if (!(__connection_check_handle_validity(connection)) ||
1023 (type != CONNECTION_ITERATOR_TYPE_REGISTERED &&
1024 type != CONNECTION_ITERATOR_TYPE_CONNECTED &&
1025 type != CONNECTION_ITERATOR_TYPE_DEFAULT)) {
1026 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1028 return CONNECTION_ERROR_INVALID_PARAMETER;
1031 int rv = _connection_libnet_get_profile_iterator(connection, type, profile_iterator);
1032 if (rv != CONNECTION_ERROR_NONE) {
1033 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get profile iterator [%d]", rv); //LCOV_EXCL_LINE
1034 CONN_UNLOCK; //LCOV_EXCL_LINE
1035 return rv; //LCOV_EXCL_LINE
1039 return CONNECTION_ERROR_NONE;
1042 EXPORT_API int connection_profile_iterator_next(connection_profile_iterator_h profile_iterator,
1043 connection_profile_h* profile)
1047 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1049 int rv = _connection_libnet_get_iterator_next(profile_iterator, profile);
1055 EXPORT_API bool connection_profile_iterator_has_next(connection_profile_iterator_h profile_iterator)
1059 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1061 int rv = _connection_libnet_iterator_has_next(profile_iterator);
1067 EXPORT_API int connection_destroy_profile_iterator(connection_profile_iterator_h profile_iterator)
1071 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1073 int rv = _connection_libnet_destroy_iterator(profile_iterator);
1079 EXPORT_API int connection_get_current_profile(connection_h connection, connection_profile_h* profile)
1083 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1085 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1086 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1088 return CONNECTION_ERROR_INVALID_PARAMETER;
1091 int rv = _connection_libnet_get_current_profile(connection, profile);
1092 if (rv != CONNECTION_ERROR_NONE) {
1093 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get current profile [%d]", rv); //LCOV_EXCL_LINE
1094 CONN_UNLOCK; //LCOV_EXCL_LINE
1095 return rv; //LCOV_EXCL_LINE
1099 return CONNECTION_ERROR_NONE;
1102 EXPORT_API int connection_get_default_cellular_service_profile(
1103 connection_h connection, connection_cellular_service_type_e type,
1104 connection_profile_h *profile)
1108 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1110 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1111 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1113 return CONNECTION_ERROR_INVALID_PARAMETER;
1116 int rv = _connection_libnet_get_cellular_service_profile(connection, type, profile);
1117 if (rv != CONNECTION_ERROR_NONE) {
1118 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get default cellular service profile [%d]", rv); //LCOV_EXCL_LINE
1119 CONN_UNLOCK; //LCOV_EXCL_LINE
1120 return rv; //LCOV_EXCL_LINE
1124 return CONNECTION_ERROR_NONE;
1127 EXPORT_API int connection_set_default_cellular_service_profile(connection_h connection,
1128 connection_cellular_service_type_e type, connection_profile_h profile)
1132 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1134 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1135 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1137 return CONNECTION_ERROR_INVALID_PARAMETER;
1140 int rv = _connection_libnet_set_cellular_service_profile_sync(connection, type, profile);
1141 if (rv != CONNECTION_ERROR_NONE) {
1142 CONNECTION_LOG(CONNECTION_ERROR, "Fail to set default cellular service profile [%d]", rv); //LCOV_EXCL_LINE
1143 CONN_UNLOCK; //LCOV_EXCL_LINE
1144 return rv; //LCOV_EXCL_LINE
1148 return CONNECTION_ERROR_NONE;
1151 EXPORT_API int connection_set_default_cellular_service_profile_async(connection_h connection,
1152 connection_cellular_service_type_e type, connection_profile_h profile,
1153 connection_set_default_cb callback, void* user_data)
1157 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1161 if (!(__connection_check_handle_validity(connection)) ||
1162 profile == NULL || callback == NULL) {
1163 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1165 return CONNECTION_ERROR_INVALID_PARAMETER;
1168 rv = _connection_libnet_set_cellular_service_profile_async(connection, type, profile);
1169 if (rv == NET_ERR_ACCESS_DENIED) {
1170 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1171 CONN_UNLOCK; //LCOV_EXCL_LINE
1172 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1173 } else if (rv != NET_ERR_NONE) {
1174 CONNECTION_LOG(CONNECTION_ERROR, "Failed to set default cellular service profile[%d]", rv); //LCOV_EXCL_LINE
1175 CONN_UNLOCK; //LCOV_EXCL_LINE
1176 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1179 __connection_set_default_cellular_service_profile_callback(connection, callback, user_data);
1182 return CONNECTION_ERROR_NONE;
1185 EXPORT_API int connection_open_profile(connection_h connection, connection_profile_h profile,
1186 connection_opened_cb callback, void* user_data)
1190 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1194 if (!(__connection_check_handle_validity(connection)) ||
1195 profile == NULL || callback == NULL) {
1196 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1198 return CONNECTION_ERROR_INVALID_PARAMETER;
1201 rv = _connection_libnet_open_profile(connection, profile);
1202 if (rv == NET_ERR_ACCESS_DENIED) {
1203 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1204 CONN_UNLOCK; //LCOV_EXCL_LINE
1205 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1206 } else if (rv != NET_ERR_NONE) {
1207 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open profile[%d]", rv); //LCOV_EXCL_LINE
1208 CONN_UNLOCK; //LCOV_EXCL_LINE
1209 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1212 __connection_open_profile_set_callback(connection, callback, user_data);
1215 return CONNECTION_ERROR_NONE;
1218 EXPORT_API int connection_close_profile(connection_h connection, connection_profile_h profile,
1219 connection_closed_cb callback, void* user_data)
1223 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1227 if (!(__connection_check_handle_validity(connection)) ||
1228 profile == NULL || callback == NULL) {
1229 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1231 return CONNECTION_ERROR_INVALID_PARAMETER;
1234 rv = _connection_libnet_close_profile(connection, profile);
1235 if (rv == NET_ERR_ACCESS_DENIED) {
1236 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1237 CONN_UNLOCK; //LCOV_EXCL_LINE
1238 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1239 } else if (rv != NET_ERR_NONE) {
1240 CONNECTION_LOG(CONNECTION_ERROR, "Failed to close profile[%d]", rv); //LCOV_EXCL_LINE
1241 CONN_UNLOCK; //LCOV_EXCL_LINE
1242 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1245 __connection_close_profile_set_callback(connection, callback, user_data);
1248 return CONNECTION_ERROR_NONE;
1251 EXPORT_API int connection_reset_profile(connection_h connection,
1252 connection_reset_option_e type, int id, connection_reset_cb callback, void *user_data)
1256 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1260 if (!(__connection_check_handle_validity(connection))) {
1261 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
1263 return CONNECTION_ERROR_INVALID_PARAMETER;
1266 if (id < 0 || id > 1) {
1267 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed"); //LCOV_EXCL_LINE
1268 CONN_UNLOCK; //LCOV_EXCL_LINE
1269 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1272 rv = _connection_libnet_reset_profile(connection, type, id);
1273 if (rv == NET_ERR_ACCESS_DENIED) {
1274 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1275 CONN_UNLOCK; //LCOV_EXCL_LINE
1276 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1277 } else if (rv != NET_ERR_NONE) {
1278 CONNECTION_LOG(CONNECTION_ERROR, "Failed to reset profile[%d]", rv); //LCOV_EXCL_LINE
1279 CONN_UNLOCK; //LCOV_EXCL_LINE
1280 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1283 __connection_reset_profile_set_callback(connection, callback, user_data);
1286 return CONNECTION_ERROR_NONE;
1289 EXPORT_API int connection_add_route(connection_h connection, const char* interface_name, const char* host_address)
1293 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1295 if (!(__connection_check_handle_validity(connection)) ||
1296 interface_name == NULL || host_address == NULL) {
1297 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1299 return CONNECTION_ERROR_INVALID_PARAMETER;
1302 int rv = _connection_libnet_add_route(connection, interface_name, host_address);
1303 if (rv != CONNECTION_ERROR_NONE) {
1304 CONNECTION_LOG(CONNECTION_ERROR, "Fail to add route [%d]", rv); //LCOV_EXCL_LINE
1305 CONN_UNLOCK; //LCOV_EXCL_LINE
1306 return rv; //LCOV_EXCL_LINE
1310 return CONNECTION_ERROR_NONE;
1313 EXPORT_API int connection_remove_route(connection_h connection, const char* interface_name, const char* host_address)
1317 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1319 if (!(__connection_check_handle_validity(connection)) ||
1320 interface_name == NULL || host_address == NULL) {
1321 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1323 return CONNECTION_ERROR_INVALID_PARAMETER;
1326 int rv = _connection_libnet_remove_route(connection, interface_name, host_address);
1327 if (rv != CONNECTION_ERROR_NONE) {
1328 CONNECTION_LOG(CONNECTION_ERROR, "Fail to remove route [%d]", rv); //LCOV_EXCL_LINE
1329 CONN_UNLOCK; //LCOV_EXCL_LINE
1330 return rv; //LCOV_EXCL_LINE
1334 return CONNECTION_ERROR_NONE;
1337 EXPORT_API int connection_add_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1341 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1343 if (!(__connection_check_handle_validity(connection)) ||
1344 interface_name == NULL || host_address == NULL) {
1345 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1347 return CONNECTION_ERROR_INVALID_PARAMETER;
1350 int rv = _connection_libnet_add_route_ipv6(connection, interface_name, host_address, gateway);
1351 if (rv != CONNECTION_ERROR_NONE) {
1352 CONNECTION_LOG(CONNECTION_ERROR, "Fail to add route ipv6 [%d]", rv); //LCOV_EXCL_LINE
1353 CONN_UNLOCK; //LCOV_EXCL_LINE
1354 return rv; //LCOV_EXCL_LINE
1358 return CONNECTION_ERROR_NONE;
1361 EXPORT_API int connection_remove_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1365 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1367 if (!(__connection_check_handle_validity(connection)) ||
1368 interface_name == NULL || host_address == NULL) {
1369 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1371 return CONNECTION_ERROR_INVALID_PARAMETER;
1374 int rv = _connection_libnet_remove_route_ipv6(connection, interface_name, host_address, gateway);
1375 if (rv != CONNECTION_ERROR_NONE) {
1376 CONNECTION_LOG(CONNECTION_ERROR, "Fail to remove route ipv6 [%d]", rv); //LCOV_EXCL_LINE
1377 CONN_UNLOCK; //LCOV_EXCL_LINE
1378 return rv; //LCOV_EXCL_LINE
1382 return CONNECTION_ERROR_NONE;
1385 EXPORT_API int connection_add_route_entry(connection_h connection,
1386 connection_address_family_e address_family, const char *interface_name,
1387 const char *host_address, const char *gateway)
1391 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1393 if (!(__connection_check_handle_validity(connection)) ||
1394 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1395 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1396 interface_name == NULL || host_address == NULL) {
1397 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1399 return CONNECTION_ERROR_INVALID_PARAMETER;
1402 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1403 int rv = _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
1404 interface_name, host_address, gateway);
1408 int rv = _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
1409 interface_name, host_address, gateway);
1415 EXPORT_API int connection_remove_route_entry(connection_h connection,
1416 connection_address_family_e address_family, const char *interface_name,
1417 const char *host_address, const char *gateway)
1421 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1423 if (!(__connection_check_handle_validity(connection)) ||
1424 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1425 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1426 interface_name == NULL || host_address == NULL) {
1427 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1429 return CONNECTION_ERROR_INVALID_PARAMETER;
1432 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1433 int rv = _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
1434 interface_name, host_address, gateway);
1438 int rv = _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
1439 interface_name, host_address, gateway);
1445 static int __get_cellular_statistic(connection_statistics_type_e statistics_type, long long *llsize)
1447 int rv = VCONF_OK, rv1 = VCONF_OK;
1448 int last_size = 0, size = 0;
1449 #if defined TIZEN_DUALSIM_ENABLE
1453 if (llsize == NULL) {
1454 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1455 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1458 switch (statistics_type) {
1459 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1460 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1461 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1462 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1465 return CONNECTION_ERROR_INVALID_PARAMETER;
1468 #if defined TIZEN_DUALSIM_ENABLE
1469 rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
1470 if (rv != VCONF_OK) {
1471 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get default subscriber id");
1473 return CONNECTION_ERROR_OPERATION_FAILED;
1479 switch (statistics_type) {
1480 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1481 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1483 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1484 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1486 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1487 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1488 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT, &size);
1490 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1491 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1492 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV, &size);
1495 #if defined TIZEN_DUALSIM_ENABLE
1498 switch (statistics_type) {
1499 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1500 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1502 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1503 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1505 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1506 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1507 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT2, &size);
1509 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1510 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1511 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV2, &size);
1517 CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
1518 return CONNECTION_ERROR_OPERATION_FAILED;
1522 if (rv != VCONF_OK || rv1 != VCONF_OK) {
1523 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular statistics"); //LCOV_EXCL_LINE
1524 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1527 *llsize = (long long)(last_size * 1000) + (long long)(size * 1000);
1528 CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", *llsize);
1530 return CONNECTION_ERROR_NONE;
1533 static int __get_statistic(connection_handle_s *conn_handle, connection_type_e connection_type,
1534 connection_statistics_type_e statistics_type, long long *llsize)
1537 unsigned long long ull_size;
1539 if (llsize == NULL) {
1540 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1541 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1544 rv = _connection_libnet_check_get_privilege();
1545 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1547 else if (rv != CONNECTION_ERROR_NONE) {
1548 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get statistics"); //LCOV_EXCL_LINE
1549 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1552 if (connection_type == CONNECTION_TYPE_CELLULAR)
1553 return __get_cellular_statistic(statistics_type, llsize);
1554 else if (connection_type == CONNECTION_TYPE_WIFI) {
1555 switch (statistics_type) {
1556 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1557 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1559 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1560 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1562 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1563 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1565 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1566 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1569 return CONNECTION_ERROR_INVALID_PARAMETER;
1572 rv = _connection_libnet_get_statistics(conn_handle, stat_type, &ull_size);
1573 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1575 else if (rv != CONNECTION_ERROR_NONE) {
1576 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get Wi-Fi statistics"); //LCOV_EXCL_LINE
1577 *llsize = 0; //LCOV_EXCL_LINE
1578 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1581 CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", ull_size);
1582 *llsize = (long long)ull_size;
1584 return CONNECTION_ERROR_INVALID_PARAMETER;
1586 return CONNECTION_ERROR_NONE;
1589 static int __reset_statistic(connection_handle_s *conn_handle,
1590 connection_type_e connection_type, connection_statistics_type_e statistics_type)
1596 if (connection_type == CONNECTION_TYPE_CELLULAR)
1597 conn_type = NET_DEVICE_CELLULAR;
1598 else if (connection_type == CONNECTION_TYPE_WIFI)
1599 conn_type = NET_DEVICE_WIFI;
1601 return CONNECTION_ERROR_INVALID_PARAMETER;
1603 switch (statistics_type) {
1604 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1605 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1607 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1608 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1610 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1611 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1613 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1614 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1617 return CONNECTION_ERROR_INVALID_PARAMETER;
1620 rv = _connection_libnet_set_statistics(conn_handle, conn_type, stat_type);
1621 if (rv != CONNECTION_ERROR_NONE)
1624 CONNECTION_LOG(CONNECTION_INFO, "connection_reset_statistics success");
1626 return CONNECTION_ERROR_NONE;
1629 EXPORT_API int connection_get_statistics(connection_h connection,
1630 connection_type_e connection_type,
1631 connection_statistics_type_e statistics_type, long long* size)
1635 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1637 if (connection_type == CONNECTION_TYPE_CELLULAR)
1638 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1639 else if (connection_type == CONNECTION_TYPE_WIFI)
1640 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1642 if (!(__connection_check_handle_validity(connection)) || size == NULL) {
1643 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1645 return CONNECTION_ERROR_INVALID_PARAMETER;
1648 int rv = __get_statistic(connection, connection_type, statistics_type, size);
1649 if (rv != CONNECTION_ERROR_NONE) {
1650 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get statistics [%d]", rv); //LCOV_EXCL_LINE
1652 return rv; //LCOV_EXCL_LINE
1656 return CONNECTION_ERROR_NONE;
1659 EXPORT_API int connection_reset_statistics(connection_h connection,
1660 connection_type_e connection_type,
1661 connection_statistics_type_e statistics_type)
1665 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1667 if (connection_type == CONNECTION_TYPE_CELLULAR)
1668 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1669 else if (connection_type == CONNECTION_TYPE_WIFI)
1670 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1672 if (!__connection_check_handle_validity(connection)) {
1673 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1675 return CONNECTION_ERROR_INVALID_PARAMETER;
1678 int rv = __reset_statistic(connection, connection_type, statistics_type);
1679 if (rv != CONNECTION_ERROR_NONE) {
1680 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get statistics [%d]", rv); //LCOV_EXCL_LINE
1682 return rv; //LCOV_EXCL_LINE
1686 return CONNECTION_ERROR_NONE;
1689 EXPORT_API int connection_foreach_ipv6_address(connection_h connection,
1690 connection_type_e connection_type, connection_ipv6_address_cb callback,
1695 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1696 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1698 GSList *ipv6_address_list = NULL;
1700 if (!(__connection_check_handle_validity(connection))) {
1701 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1703 return CONNECTION_ERROR_INVALID_PARAMETER;
1706 int rv = CONNECTION_ERROR_NONE;
1708 switch (connection_type) {
1709 case CONNECTION_TYPE_WIFI:
1710 rv = net_foreach_ipv6_address(NET_DEVICE_WIFI,
1711 &ipv6_address_list);
1713 case CONNECTION_TYPE_CELLULAR:
1714 rv = net_foreach_ipv6_address(NET_DEVICE_CELLULAR,
1715 &ipv6_address_list);
1717 case CONNECTION_TYPE_ETHERNET:
1718 rv = net_foreach_ipv6_address(NET_DEVICE_ETHERNET,
1719 &ipv6_address_list);
1721 case CONNECTION_TYPE_BT:
1722 rv = net_foreach_ipv6_address(NET_DEVICE_BLUETOOTH,
1723 &ipv6_address_list);
1726 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1728 return CONNECTION_ERROR_INVALID_PARAMETER;
1731 if (rv != NET_ERR_NONE) {
1732 CONNECTION_LOG(CONNECTION_ERROR, "net_get_multiple_id_address" //LCOV_EXCL_LINE
1733 " Failed = %d\n", rv);
1734 CONN_UNLOCK; //LCOV_EXCL_LINE
1735 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1739 for (list = ipv6_address_list; list; list = list->next) {
1740 rv = callback((char *)list->data, user_data);
1745 g_slist_free_full(ipv6_address_list, g_free);
1746 ipv6_address_list = NULL;
1749 return CONNECTION_ERROR_NONE;
1752 EXPORT_API int connection_profile_start_tcpdump(connection_h connection)
1758 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1760 if (!(__connection_check_handle_validity(connection))) {
1761 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1763 return CONNECTION_ERROR_INVALID_PARAMETER;
1766 ret = _connection_libnet_start_tcpdump(connection);
1767 if (ret != CONNECTION_ERROR_NONE) {
1768 CONNECTION_LOG(CONNECTION_ERROR, "Failed to start tcpdump (%d)", ret); //LCOV_EXCL_LINE
1769 CONN_UNLOCK; //LCOV_EXCL_LINE
1770 return ret; //LCOV_EXCL_LINE
1774 return CONNECTION_ERROR_NONE;
1777 EXPORT_API int connection_profile_stop_tcpdump(connection_h connection)
1783 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1785 if (!(__connection_check_handle_validity(connection))) {
1786 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1788 return CONNECTION_ERROR_INVALID_PARAMETER;
1791 ret = _connection_libnet_stop_tcpdump(connection);
1792 if (ret != CONNECTION_ERROR_NONE) {
1793 CONNECTION_LOG(CONNECTION_ERROR, "Failed to stop tcpdump (%d)", ret); //LCOV_EXCL_LINE
1794 CONN_UNLOCK; //LCOV_EXCL_LINE
1795 return ret; //LCOV_EXCL_LINE
1799 return CONNECTION_ERROR_NONE;
1802 EXPORT_API int connection_profile_get_tcpdump_state(connection_h connection, gboolean *tcpdump_state)
1808 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1810 if (!(__connection_check_handle_validity(connection)) || !tcpdump_state) {
1811 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1813 return CONNECTION_ERROR_INVALID_PARAMETER;
1816 ret = _connection_libnet_get_tcpdump_state(connection, tcpdump_state);
1817 if (ret != CONNECTION_ERROR_NONE) {
1818 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get the tcpdump state (%d)", ret); //LCOV_EXCL_LINE
1819 CONN_UNLOCK; //LCOV_EXCL_LINE
1820 return ret; //LCOV_EXCL_LINE
1824 return CONNECTION_ERROR_NONE;
1827 EXPORT_API int connection_profile_save_ethernet_eap_config(connection_h connection,
1828 connection_profile_h profile)
1832 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1836 if (!__connection_check_handle_validity(connection) ||
1837 !_connection_libnet_check_profile_validity(profile)) {
1838 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1840 return CONNECTION_ERROR_INVALID_PARAMETER;
1843 rv = _connection_libnet_profile_save_ethernet_eap_config(connection, profile);
1844 if (rv != CONNECTION_ERROR_NONE) {
1845 CONNECTION_LOG(CONNECTION_ERROR, "Failed to save ethernet eap config."); //LCOV_EXCL_LINE
1846 CONN_UNLOCK; //LCOV_EXCL_LINE
1847 return rv; //LCOV_EXCL_LINE
1851 return CONNECTION_ERROR_NONE;