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");
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);
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
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
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);
205 _connection_libnet_deinit(connection);
207 conn_handle_list = g_slist_remove(conn_handle_list, connection);
213 return CONNECTION_ERROR_NONE;
216 EXPORT_API int connection_create_cs(int tid, connection_h *connection)
220 rv = connection_create(connection);
221 if (rv == CONNECTION_ERROR_NONE) {
223 _connection_set_cs_tid(tid, *connection);
230 EXPORT_API int connection_destroy_cs(int tid, connection_h connection)
235 _connection_unset_cs_tid(tid, connection);
238 rv = connection_destroy(connection);
243 EXPORT_API int connection_get_type(connection_h connection, connection_type_e* type)
250 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
252 if (type == NULL || !(__connection_check_handle_validity(connection))) {
253 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
255 return CONNECTION_ERROR_INVALID_PARAMETER;
258 rv = vconf_get_int(VCONFKEY_NETWORK_STATUS, &status);
259 if (rv != VCONF_OK) {
260 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed = %d", status); //LCOV_EXCL_LINE
262 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
265 CONNECTION_LOG(CONNECTION_INFO, "Connected Network = %d", status);
267 *type = __connection_convert_net_state(status);
270 return CONNECTION_ERROR_NONE;
273 EXPORT_API int connection_get_ip_address(connection_h connection,
274 connection_address_family_e address_family, char** ip_address)
278 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
280 if (ip_address == NULL || !(__connection_check_handle_validity(connection))) {
281 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
283 return CONNECTION_ERROR_INVALID_PARAMETER;
286 switch (address_family) {
287 case CONNECTION_ADDRESS_FAMILY_IPV4:
288 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP);
290 case CONNECTION_ADDRESS_FAMILY_IPV6:
291 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP6);
294 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
296 return CONNECTION_ERROR_INVALID_PARAMETER;
299 if (*ip_address == NULL) {
300 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
302 return CONNECTION_ERROR_OPERATION_FAILED;//LCOV_EXCL_LINE
306 return CONNECTION_ERROR_NONE;
309 EXPORT_API int connection_get_proxy(connection_h connection,
310 connection_address_family_e address_family, char** proxy)
314 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
316 if (proxy == NULL || !(__connection_check_handle_validity(connection))) {
317 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
319 return CONNECTION_ERROR_INVALID_PARAMETER;
322 switch (address_family) {
323 case CONNECTION_ADDRESS_FAMILY_IPV4:
324 case CONNECTION_ADDRESS_FAMILY_IPV6:
325 *proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
328 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
330 return CONNECTION_ERROR_INVALID_PARAMETER;
333 if (*proxy == NULL) {
334 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
336 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
340 return CONNECTION_ERROR_NONE;
343 EXPORT_API int connection_get_mac_address(connection_h connection, connection_type_e type, char** mac_addr)
346 char buf[CONNECTION_MAC_INFO_LENGTH + 1];
350 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE, ETHERNET_FEATURE);
352 if (type == CONNECTION_TYPE_WIFI)
353 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
354 else if (type == CONNECTION_TYPE_ETHERNET) //LCOV_EXCL_LINE
355 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE); //LCOV_EXCL_LINE
357 if (mac_addr == NULL || !(__connection_check_handle_validity(connection))) {
358 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
360 return CONNECTION_ERROR_INVALID_PARAMETER;
364 case CONNECTION_TYPE_WIFI:
365 if (__builtin_expect(tv_profile == -1, 0)) {
367 system_info_get_platform_string("http://tizen.org/feature/profile", &profileName);
368 if (*profileName == 't' || *profileName == 'T')
374 if (tv_profile == 1) {
375 fp = fopen(WIFI_MAC_INFO_FILE, "r");
377 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", WIFI_MAC_INFO_FILE); //LCOV_EXCL_LINE
379 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
382 if (fgets(buf, sizeof(buf), fp) == NULL) {
383 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", WIFI_MAC_INFO_FILE); //LCOV_EXCL_LINE
384 fclose(fp); //LCOV_EXCL_LINE
386 return CONNECTION_ERROR_OPERATION_FAILED;
389 CONNECTION_LOG(CONNECTION_INFO, "%s : %s", WIFI_MAC_INFO_FILE, buf);
391 *mac_addr = (char *)malloc(CONNECTION_MAC_INFO_LENGTH + 1);
392 if (*mac_addr == NULL) {
393 CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed"); //LCOV_EXCL_LINE
394 fclose(fp); //LCOV_EXCL_LINE
396 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
398 g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1);
401 *mac_addr = vconf_get_str(VCONFKEY_WIFI_BSSID_ADDRESS);
403 if (*mac_addr == NULL) {
404 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get vconf from %s", VCONFKEY_WIFI_BSSID_ADDRESS); //LCOV_EXCL_LINE
406 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
411 case CONNECTION_TYPE_ETHERNET:
412 fp = fopen(ETHERNET_MAC_INFO_FILE, "r");
414 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", ETHERNET_MAC_INFO_FILE);
416 return CONNECTION_ERROR_OUT_OF_MEMORY;
419 if (fgets(buf, sizeof(buf), fp) == NULL) {
420 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", ETHERNET_MAC_INFO_FILE);
423 return CONNECTION_ERROR_OPERATION_FAILED;
426 CONNECTION_LOG(CONNECTION_INFO, "%s : %s", ETHERNET_MAC_INFO_FILE, buf);
428 *mac_addr = (char *)malloc(CONNECTION_MAC_INFO_LENGTH + 1);
429 if (*mac_addr == NULL) {
430 CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed");
433 return CONNECTION_ERROR_OUT_OF_MEMORY;
436 g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1);
442 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
444 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
447 /* Checking Invalid MAC Address */
448 if ((strcmp(*mac_addr, "00:00:00:00:00:00") == 0) ||
449 (strcmp(*mac_addr, "ff:ff:ff:ff:ff:ff") == 0)) {
450 CONNECTION_LOG(CONNECTION_ERROR, "MAC Address(%s) is invalid", *mac_addr); //LCOV_EXCL_LINE
452 return CONNECTION_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
455 CONNECTION_LOG(CONNECTION_INFO, "MAC Address %s", *mac_addr);
458 return CONNECTION_ERROR_NONE;
462 EXPORT_API int connection_is_metered_network(connection_h connection, bool* is_metered)
466 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
468 if (is_metered == NULL || !(__connection_check_handle_validity(connection))) {
469 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
471 return CONNECTION_ERROR_INVALID_PARAMETER;
474 int rv = _connection_libnet_get_metered_state(connection, is_metered);
475 if (rv != CONNECTION_ERROR_NONE) {
476 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get metered state[%d]", rv); //LCOV_EXCL_LINE
478 return rv; //LCOV_EXCL_LINE
481 CONNECTION_LOG(CONNECTION_INFO, "metered state: %s", is_metered ? "true" : "false");
483 return CONNECTION_ERROR_NONE;
487 EXPORT_API int connection_get_cellular_state(connection_h connection, connection_cellular_state_e* state)
491 int cellular_state = 0;
492 #if defined TIZEN_DUALSIM_ENABLE
498 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
500 if (state == NULL || !(__connection_check_handle_validity(connection))) {
501 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
503 return CONNECTION_ERROR_INVALID_PARAMETER;
506 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &status);
507 if (rv != VCONF_OK) {
508 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
510 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
513 CONNECTION_LOG(CONNECTION_INFO, "Cellular: %d", status);
514 *state = __connection_convert_cellular_state(status);
516 if (*state == CONNECTION_CELLULAR_STATE_AVAILABLE) {
517 #if defined TIZEN_DUALSIM_ENABLE
518 rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
519 if (rv != VCONF_OK) {
520 CONNECTION_LOG(CONNECTION_ERROR,
521 "Failed to get default subscriber id", sim_id);
523 return CONNECTION_ERROR_OPERATION_FAILED;
527 case CONNECTION_CELLULAR_SUBSCRIBER_1:
529 rv = vconf_get_int(VCONFKEY_DNET_STATE, &cellular_state);
530 #if defined TIZEN_DUALSIM_ENABLE
533 case CONNECTION_CELLULAR_SUBSCRIBER_2:
534 rv = vconf_get_int(VCONFKEY_DNET_STATE2, &cellular_state);
538 CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
540 return CONNECTION_ERROR_OPERATION_FAILED;
543 if (rv != VCONF_OK) {
544 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
546 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
550 CONNECTION_LOG(CONNECTION_INFO, "Cellular state: %d", cellular_state);
552 if (cellular_state == VCONFKEY_DNET_NORMAL_CONNECTED ||
553 cellular_state == VCONFKEY_DNET_SECURE_CONNECTED ||
554 cellular_state == VCONFKEY_DNET_TRANSFER)
555 *state = CONNECTION_CELLULAR_STATE_CONNECTED;
558 return CONNECTION_ERROR_NONE;
561 EXPORT_API int connection_get_wifi_state(connection_h connection, connection_wifi_state_e* state)
565 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
567 if (state == NULL || !(__connection_check_handle_validity(connection))) {
568 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
570 return CONNECTION_ERROR_INVALID_PARAMETER;
573 int rv = _connection_libnet_get_wifi_state(connection, state);
574 if (rv != CONNECTION_ERROR_NONE) {
575 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get Wi-Fi state[%d]", rv); //LCOV_EXCL_LINE
577 return rv; //LCOV_EXCL_LINE
580 CONNECTION_LOG(CONNECTION_INFO, "Wi-Fi state: %d", *state);
583 return CONNECTION_ERROR_NONE;
587 EXPORT_API int connection_get_ethernet_state(connection_h connection, connection_ethernet_state_e *state)
591 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
593 if (state == NULL || !(__connection_check_handle_validity(connection))) {
594 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
596 return CONNECTION_ERROR_INVALID_PARAMETER;
599 int rv = _connection_libnet_get_ethernet_state(connection, state);
600 if (rv != CONNECTION_ERROR_NONE) {
601 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get ethernet state[%d]", rv); //LCOV_EXCL_LINE
603 return rv; //LCOV_EXCL_LINE
607 return CONNECTION_ERROR_NONE;
610 EXPORT_API int connection_get_ethernet_cable_state(connection_h connection, connection_ethernet_cable_state_e *state)
614 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
616 if (state == NULL || !(__connection_check_handle_validity(connection))) {
617 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
619 return CONNECTION_ERROR_INVALID_PARAMETER;
622 int rv = _connection_libnet_get_ethernet_cable_state(connection, state);
623 if (rv != CONNECTION_ERROR_NONE) {
624 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get ethernet cable state[%d]", rv); //LCOV_EXCL_LINE
626 return rv; //LCOV_EXCL_LINE
630 return CONNECTION_ERROR_NONE;
633 EXPORT_API int connection_set_ethernet_cable_state_chaged_cb(connection_h connection,
634 connection_ethernet_cable_state_chaged_cb callback, void *user_data)
636 DEPRECATED_LOG(__FUNCTION__, "connection_set_ethernet_cable_state_changed_cb");
640 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
642 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
643 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
645 return CONNECTION_ERROR_INVALID_PARAMETER;
648 DEPRECATED_LOG("connection_ethernet_cable_state_chaged_cb",
649 "connection_ethernet_cable_state_changed_cb");
651 __connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data);
654 return CONNECTION_ERROR_NONE;
657 EXPORT_API int connection_unset_ethernet_cable_state_chaged_cb(connection_h connection)
659 DEPRECATED_LOG(__FUNCTION__, "connection_unset_ethernet_cable_state_changed_cb");
663 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
665 if (!(__connection_check_handle_validity(connection))) {
666 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
668 return CONNECTION_ERROR_INVALID_PARAMETER;
671 __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
674 return CONNECTION_ERROR_NONE;
677 EXPORT_API int connection_set_ethernet_cable_state_changed_cb(connection_h connection,
678 connection_ethernet_cable_state_changed_cb callback, void *user_data)
682 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
684 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
685 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
687 return CONNECTION_ERROR_INVALID_PARAMETER;
690 __connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data);
693 return CONNECTION_ERROR_NONE;
696 EXPORT_API int connection_unset_ethernet_cable_state_changed_cb(connection_h connection)
700 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
702 if (!(__connection_check_handle_validity(connection))) {
703 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
705 return CONNECTION_ERROR_INVALID_PARAMETER;
708 __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
711 return CONNECTION_ERROR_NONE;
715 EXPORT_API int connection_get_bt_state(connection_h connection, connection_bt_state_e *state)
719 CHECK_FEATURE_SUPPORTED(TETHERING_BLUETOOTH_FEATURE);
721 if (state == NULL || !(__connection_check_handle_validity(connection))) {
722 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
724 return CONNECTION_ERROR_INVALID_PARAMETER;
727 int rv = _connection_libnet_get_bluetooth_state(connection, state);
728 if (rv != CONNECTION_ERROR_NONE) {
729 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get bluetooth state[%d]", rv); //LCOV_EXCL_LINE
731 return rv; //LCOV_EXCL_LINE
735 return CONNECTION_ERROR_NONE;
738 EXPORT_API int connection_set_type_changed_cb(connection_h connection,
739 connection_type_changed_cb callback, void* user_data)
743 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
745 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
746 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
748 return CONNECTION_ERROR_INVALID_PARAMETER;
751 __connection_set_type_changed_callback(connection, callback, user_data);
754 return CONNECTION_ERROR_NONE;
757 EXPORT_API int connection_unset_type_changed_cb(connection_h connection)
761 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
763 if (!(__connection_check_handle_validity(connection))) {
764 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
766 return CONNECTION_ERROR_INVALID_PARAMETER;
769 __connection_set_type_changed_callback(connection, NULL, NULL);
772 return CONNECTION_ERROR_NONE;
775 EXPORT_API int connection_set_ip_address_changed_cb(connection_h connection,
776 connection_address_changed_cb callback, void* user_data)
780 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
782 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
783 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
785 return CONNECTION_ERROR_INVALID_PARAMETER;
788 __connection_set_ip_changed_callback(connection, callback, user_data);
791 return CONNECTION_ERROR_NONE;
794 EXPORT_API int connection_unset_ip_address_changed_cb(connection_h connection)
798 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
800 if (!(__connection_check_handle_validity(connection))) {
801 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
803 return CONNECTION_ERROR_INVALID_PARAMETER;
806 __connection_set_ip_changed_callback(connection, NULL, NULL);
809 return CONNECTION_ERROR_NONE;
812 EXPORT_API int connection_set_proxy_address_changed_cb(connection_h connection,
813 connection_address_changed_cb callback, void* user_data)
817 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
819 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
820 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
822 return CONNECTION_ERROR_INVALID_PARAMETER;
825 __connection_set_proxy_changed_callback(connection, callback, user_data);
828 return CONNECTION_ERROR_NONE;
831 EXPORT_API int connection_unset_proxy_address_changed_cb(connection_h connection)
835 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
837 if (!(__connection_check_handle_validity(connection))) {
838 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
840 return CONNECTION_ERROR_INVALID_PARAMETER;
843 __connection_set_proxy_changed_callback(connection, NULL, NULL);
846 return CONNECTION_ERROR_NONE;
849 EXPORT_API int connection_set_internet_state_changed_cb(connection_h connection,
850 connection_internet_state_changed_cb callback, void *user_data)
854 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
856 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
857 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
859 return CONNECTION_ERROR_INVALID_PARAMETER;
862 __connection_set_internet_state_changed_callback(connection, callback, user_data);
865 return CONNECTION_ERROR_NONE;
868 EXPORT_API int connection_unset_internet_state_changed_cb(connection_h connection)
872 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
874 if (!(__connection_check_handle_validity(connection))) {
875 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
877 return CONNECTION_ERROR_INVALID_PARAMETER;
880 __connection_set_internet_state_changed_callback(connection, NULL, NULL);
883 return CONNECTION_ERROR_NONE;
886 EXPORT_API int connection_add_profile(connection_h connection, connection_profile_h profile)
889 connection_handle_s *conn_handle = (connection_handle_s *)connection;
890 net_profile_info_t *profile_info = (net_profile_info_t *)profile;
894 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
896 if (!(__connection_check_handle_validity(connection)) ||
897 !(_connection_libnet_check_profile_validity(profile))) {
898 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
900 return CONNECTION_ERROR_INVALID_PARAMETER;
903 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
904 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
906 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
909 if (profile_info->ProfileInfo.Pdp.PSModemPath[0] != '/' ||
910 strlen(profile_info->ProfileInfo.Pdp.PSModemPath) < 2) {
911 CONNECTION_LOG(CONNECTION_ERROR, "Modem object path is NULL"); //LCOV_EXCL_LINE
913 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
916 rv = net_add_profile(conn_handle->network_info_handle,
917 profile_info->ProfileInfo.Pdp.ServiceType, profile_info);
918 if (rv == NET_ERR_ACCESS_DENIED) {
919 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
921 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
922 } else if (rv != NET_ERR_NONE) {
923 CONNECTION_LOG(CONNECTION_ERROR, "Failed to add profile[%d]", rv); //LCOV_EXCL_LINE
925 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
929 return CONNECTION_ERROR_NONE;
932 EXPORT_API int connection_remove_profile(connection_h connection, connection_profile_h profile)
935 connection_handle_s *conn_handle = (connection_handle_s *)connection;
936 net_profile_info_t *profile_info = (net_profile_info_t *)profile;
940 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
942 if (!(__connection_check_handle_validity(connection)) ||
943 !(_connection_libnet_check_profile_validity(profile))) {
944 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
946 return CONNECTION_ERROR_INVALID_PARAMETER;
949 if (profile_info->profile_type != NET_DEVICE_CELLULAR &&
950 profile_info->profile_type != NET_DEVICE_MESH &&
951 profile_info->profile_type != NET_DEVICE_WIFI) {
952 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
954 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
957 rv = net_delete_profile(conn_handle->network_info_handle, profile_info->ProfileName);
958 if (rv == NET_ERR_ACCESS_DENIED) {
959 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
961 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
962 } else if (rv != NET_ERR_NONE) {
963 CONNECTION_LOG(CONNECTION_ERROR, "Failed to delete profile[%d]", rv); //LCOV_EXCL_LINE
965 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
969 return CONNECTION_ERROR_NONE;
972 EXPORT_API int connection_update_profile(connection_h connection, connection_profile_h profile)
975 connection_handle_s *conn_handle = (connection_handle_s *)connection;
976 net_profile_info_t *profile_info = (net_profile_info_t *)profile;
980 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
982 if (!(__connection_check_handle_validity(connection)) ||
983 !(_connection_libnet_check_profile_validity(profile))) {
984 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
986 return CONNECTION_ERROR_INVALID_PARAMETER;
989 rv = net_modify_profile(conn_handle->network_info_handle,
990 profile_info->ProfileName, (net_profile_info_t*)profile);
991 if (rv == NET_ERR_ACCESS_DENIED) {
992 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
994 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
995 } else if (rv != NET_ERR_NONE) {
996 CONNECTION_LOG(CONNECTION_ERROR, "Failed to modify profile[%d]", rv); //LCOV_EXCL_LINE
998 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1002 return CONNECTION_ERROR_NONE;
1005 EXPORT_API int connection_get_profile_iterator(connection_h connection,
1006 connection_iterator_type_e type, connection_profile_iterator_h* profile_iterator)
1010 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1012 if (!(__connection_check_handle_validity(connection)) ||
1013 (type != CONNECTION_ITERATOR_TYPE_REGISTERED &&
1014 type != CONNECTION_ITERATOR_TYPE_CONNECTED &&
1015 type != CONNECTION_ITERATOR_TYPE_DEFAULT)) {
1016 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1018 return CONNECTION_ERROR_INVALID_PARAMETER;
1021 int rv = _connection_libnet_get_profile_iterator(connection, type, profile_iterator);
1022 if (rv != CONNECTION_ERROR_NONE) {
1023 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get profile iterator [%d]", rv); //LCOV_EXCL_LINE
1025 return rv; //LCOV_EXCL_LINE
1029 return CONNECTION_ERROR_NONE;
1032 EXPORT_API int connection_profile_iterator_next(connection_profile_iterator_h profile_iterator,
1033 connection_profile_h* profile)
1037 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1039 int rv = _connection_libnet_get_iterator_next(profile_iterator, profile);
1045 EXPORT_API bool connection_profile_iterator_has_next(connection_profile_iterator_h profile_iterator)
1049 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1051 int rv = _connection_libnet_iterator_has_next(profile_iterator);
1057 EXPORT_API int connection_destroy_profile_iterator(connection_profile_iterator_h profile_iterator)
1061 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1063 int rv = _connection_libnet_destroy_iterator(profile_iterator);
1069 EXPORT_API int connection_get_current_profile(connection_h connection, connection_profile_h* profile)
1073 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1075 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1076 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1078 return CONNECTION_ERROR_INVALID_PARAMETER;
1081 int rv = _connection_libnet_get_current_profile(connection, profile);
1082 if (rv != CONNECTION_ERROR_NONE) {
1083 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get current profile [%d]", rv); //LCOV_EXCL_LINE
1085 return rv; //LCOV_EXCL_LINE
1089 return CONNECTION_ERROR_NONE;
1092 EXPORT_API int connection_get_default_cellular_service_profile(
1093 connection_h connection, connection_cellular_service_type_e type,
1094 connection_profile_h *profile)
1098 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1100 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1101 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1103 return CONNECTION_ERROR_INVALID_PARAMETER;
1106 int rv = _connection_libnet_get_cellular_service_profile(connection, type, profile);
1107 if (rv != CONNECTION_ERROR_NONE) {
1108 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get default cellular service profile [%d]", rv); //LCOV_EXCL_LINE
1110 return rv; //LCOV_EXCL_LINE
1114 return CONNECTION_ERROR_NONE;
1117 EXPORT_API int connection_set_default_cellular_service_profile(connection_h connection,
1118 connection_cellular_service_type_e type, connection_profile_h profile)
1122 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1124 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1125 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1127 return CONNECTION_ERROR_INVALID_PARAMETER;
1130 int rv = _connection_libnet_set_cellular_service_profile_sync(connection, type, profile);
1131 if (rv != CONNECTION_ERROR_NONE) {
1132 CONNECTION_LOG(CONNECTION_ERROR, "Fail to set default cellular service profile [%d]", rv); //LCOV_EXCL_LINE
1134 return rv; //LCOV_EXCL_LINE
1138 return CONNECTION_ERROR_NONE;
1141 EXPORT_API int connection_set_default_cellular_service_profile_async(connection_h connection,
1142 connection_cellular_service_type_e type, connection_profile_h profile,
1143 connection_set_default_cb callback, void* user_data)
1147 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1151 if (!(__connection_check_handle_validity(connection)) ||
1152 profile == NULL || callback == NULL) {
1153 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1155 return CONNECTION_ERROR_INVALID_PARAMETER;
1158 rv = _connection_libnet_set_cellular_service_profile_async(connection, type, profile);
1159 if (rv == NET_ERR_ACCESS_DENIED) {
1160 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1162 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1163 } else if (rv != NET_ERR_NONE) {
1164 CONNECTION_LOG(CONNECTION_ERROR, "Failed to set default cellular service profile[%d]", rv); //LCOV_EXCL_LINE
1166 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1169 __connection_set_default_cellular_service_profile_callback(connection, callback, user_data);
1172 return CONNECTION_ERROR_NONE;
1175 EXPORT_API int connection_open_profile(connection_h connection, connection_profile_h profile,
1176 connection_opened_cb callback, void* user_data)
1180 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1184 if (!(__connection_check_handle_validity(connection)) ||
1185 profile == NULL || callback == NULL) {
1186 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1188 return CONNECTION_ERROR_INVALID_PARAMETER;
1191 rv = _connection_libnet_open_profile(connection, profile);
1192 if (rv == NET_ERR_ACCESS_DENIED) {
1193 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1195 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1196 } else if (rv != NET_ERR_NONE) {
1197 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open profile[%d]", rv); //LCOV_EXCL_LINE
1199 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1202 __connection_open_profile_set_callback(connection, callback, user_data);
1205 return CONNECTION_ERROR_NONE;
1208 EXPORT_API int connection_close_profile(connection_h connection, connection_profile_h profile,
1209 connection_closed_cb callback, void* user_data)
1213 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1217 if (!(__connection_check_handle_validity(connection)) ||
1218 profile == NULL || callback == NULL) {
1219 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1221 return CONNECTION_ERROR_INVALID_PARAMETER;
1224 rv = _connection_libnet_close_profile(connection, profile);
1225 if (rv == NET_ERR_ACCESS_DENIED) {
1226 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1228 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1229 } else if (rv != NET_ERR_NONE) {
1230 CONNECTION_LOG(CONNECTION_ERROR, "Failed to close profile[%d]", rv); //LCOV_EXCL_LINE
1232 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1235 __connection_close_profile_set_callback(connection, callback, user_data);
1238 return CONNECTION_ERROR_NONE;
1241 EXPORT_API int connection_reset_profile(connection_h connection,
1242 connection_reset_option_e type, int id, connection_reset_cb callback, void *user_data)
1246 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1250 if (!(__connection_check_handle_validity(connection))) {
1251 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
1253 return CONNECTION_ERROR_INVALID_PARAMETER;
1256 if (id < 0 || id > 1) {
1257 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed"); //LCOV_EXCL_LINE
1259 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1262 rv = _connection_libnet_reset_profile(connection, type, id);
1263 if (rv == NET_ERR_ACCESS_DENIED) {
1264 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1266 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1267 } else if (rv != NET_ERR_NONE) {
1268 CONNECTION_LOG(CONNECTION_ERROR, "Failed to reset profile[%d]", rv); //LCOV_EXCL_LINE
1270 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1273 __connection_reset_profile_set_callback(connection, callback, user_data);
1276 return CONNECTION_ERROR_NONE;
1279 EXPORT_API int connection_add_route(connection_h connection, const char* interface_name, const char* host_address)
1283 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1285 if (!(__connection_check_handle_validity(connection)) ||
1286 interface_name == NULL || host_address == NULL) {
1287 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1289 return CONNECTION_ERROR_INVALID_PARAMETER;
1292 int rv = _connection_libnet_add_route(connection, interface_name, host_address);
1293 if (rv != CONNECTION_ERROR_NONE) {
1294 CONNECTION_LOG(CONNECTION_ERROR, "Fail to add route [%d]", rv); //LCOV_EXCL_LINE
1296 return rv; //LCOV_EXCL_LINE
1300 return CONNECTION_ERROR_NONE;
1303 EXPORT_API int connection_remove_route(connection_h connection, const char* interface_name, const char* host_address)
1307 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1309 if (!(__connection_check_handle_validity(connection)) ||
1310 interface_name == NULL || host_address == NULL) {
1311 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1313 return CONNECTION_ERROR_INVALID_PARAMETER;
1316 int rv = _connection_libnet_remove_route(connection, interface_name, host_address);
1317 if (rv != CONNECTION_ERROR_NONE) {
1318 CONNECTION_LOG(CONNECTION_ERROR, "Fail to remove route [%d]", rv); //LCOV_EXCL_LINE
1320 return rv; //LCOV_EXCL_LINE
1324 return CONNECTION_ERROR_NONE;
1327 EXPORT_API int connection_add_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1331 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1333 if (!(__connection_check_handle_validity(connection)) ||
1334 interface_name == NULL || host_address == NULL) {
1335 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1337 return CONNECTION_ERROR_INVALID_PARAMETER;
1340 int rv = _connection_libnet_add_route_ipv6(connection, interface_name, host_address, gateway);
1341 if (rv != CONNECTION_ERROR_NONE) {
1342 CONNECTION_LOG(CONNECTION_ERROR, "Fail to add route ipv6 [%d]", rv); //LCOV_EXCL_LINE
1344 return rv; //LCOV_EXCL_LINE
1348 return CONNECTION_ERROR_NONE;
1351 EXPORT_API int connection_remove_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1355 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1357 if (!(__connection_check_handle_validity(connection)) ||
1358 interface_name == NULL || host_address == NULL) {
1359 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1361 return CONNECTION_ERROR_INVALID_PARAMETER;
1364 int rv = _connection_libnet_remove_route_ipv6(connection, interface_name, host_address, gateway);
1365 if (rv != CONNECTION_ERROR_NONE) {
1366 CONNECTION_LOG(CONNECTION_ERROR, "Fail to remove route ipv6 [%d]", rv); //LCOV_EXCL_LINE
1368 return rv; //LCOV_EXCL_LINE
1372 return CONNECTION_ERROR_NONE;
1375 EXPORT_API int connection_add_route_entry(connection_h connection,
1376 connection_address_family_e address_family, const char *interface_name,
1377 const char *host_address, const char *gateway)
1381 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1383 if (!(__connection_check_handle_validity(connection)) ||
1384 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1385 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1386 interface_name == NULL || host_address == NULL) {
1387 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1389 return CONNECTION_ERROR_INVALID_PARAMETER;
1392 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1393 int rv = _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
1394 interface_name, host_address, gateway);
1398 int rv = _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
1399 interface_name, host_address, gateway);
1405 return CONNECTION_ERROR_NONE;
1408 EXPORT_API int connection_remove_route_entry(connection_h connection,
1409 connection_address_family_e address_family, const char *interface_name,
1410 const char *host_address, const char *gateway)
1414 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1416 if (!(__connection_check_handle_validity(connection)) ||
1417 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1418 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1419 interface_name == NULL || host_address == NULL) {
1420 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1422 return CONNECTION_ERROR_INVALID_PARAMETER;
1425 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1426 int rv = _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
1427 interface_name, host_address, gateway);
1431 int rv = _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
1432 interface_name, host_address, gateway);
1438 return CONNECTION_ERROR_NONE;
1441 static int __get_cellular_statistic(connection_statistics_type_e statistics_type, long long *llsize)
1443 int rv = VCONF_OK, rv1 = VCONF_OK;
1444 int last_size = 0, size = 0;
1445 #if defined TIZEN_DUALSIM_ENABLE
1449 if (llsize == NULL) {
1450 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1451 return CONNECTION_ERROR_INVALID_PARAMETER;
1454 switch (statistics_type) {
1455 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1456 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1457 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1458 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1461 return CONNECTION_ERROR_INVALID_PARAMETER;
1464 #if defined TIZEN_DUALSIM_ENABLE
1465 rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
1466 if (rv != VCONF_OK) {
1467 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get default subscriber id");
1469 return CONNECTION_ERROR_OPERATION_FAILED;
1475 switch (statistics_type) {
1476 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1477 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1479 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1480 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1482 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1483 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1484 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT, &size);
1486 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1487 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1488 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV, &size);
1491 #if defined TIZEN_DUALSIM_ENABLE
1494 switch (statistics_type) {
1495 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1496 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1498 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1499 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1501 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1502 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1503 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT2, &size);
1505 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1506 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1507 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV2, &size);
1513 CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
1514 return CONNECTION_ERROR_OPERATION_FAILED;
1518 if (rv != VCONF_OK || rv1 != VCONF_OK) {
1519 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular statistics"); //LCOV_EXCL_LINE
1520 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1523 *llsize = (long long)(last_size * 1000) + (long long)(size * 1000);
1524 CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", *llsize);
1526 return CONNECTION_ERROR_NONE;
1529 static int __get_statistic(connection_handle_s *conn_handle, connection_type_e connection_type,
1530 connection_statistics_type_e statistics_type, long long *llsize)
1533 unsigned long long ull_size;
1535 if (llsize == NULL) {
1536 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1537 return CONNECTION_ERROR_INVALID_PARAMETER;
1540 rv = _connection_libnet_check_get_privilege();
1541 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1543 else if (rv != CONNECTION_ERROR_NONE) {
1544 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get statistics"); //LCOV_EXCL_LINE
1545 return CONNECTION_ERROR_OPERATION_FAILED;
1548 if (connection_type == CONNECTION_TYPE_CELLULAR)
1549 return __get_cellular_statistic(statistics_type, llsize);
1550 else if (connection_type == CONNECTION_TYPE_WIFI) {
1551 switch (statistics_type) {
1552 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1553 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1555 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1556 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1558 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1559 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1561 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1562 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1565 return CONNECTION_ERROR_INVALID_PARAMETER;
1568 rv = _connection_libnet_get_statistics(conn_handle, stat_type, &ull_size);
1569 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1571 else if (rv != CONNECTION_ERROR_NONE) {
1572 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get Wi-Fi statistics"); //LCOV_EXCL_LINE
1573 *llsize = 0; //LCOV_EXCL_LINE
1574 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1577 CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", ull_size);
1578 *llsize = (long long)ull_size;
1580 return CONNECTION_ERROR_INVALID_PARAMETER;
1582 return CONNECTION_ERROR_NONE;
1585 static int __reset_statistic(connection_handle_s *conn_handle,
1586 connection_type_e connection_type, connection_statistics_type_e statistics_type)
1592 if (connection_type == CONNECTION_TYPE_CELLULAR)
1593 conn_type = NET_DEVICE_CELLULAR;
1594 else if (connection_type == CONNECTION_TYPE_WIFI)
1595 conn_type = NET_DEVICE_WIFI;
1597 return CONNECTION_ERROR_INVALID_PARAMETER;
1599 switch (statistics_type) {
1600 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1601 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1603 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1604 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1606 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1607 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1609 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1610 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1613 return CONNECTION_ERROR_INVALID_PARAMETER;
1616 rv = _connection_libnet_set_statistics(conn_handle, conn_type, stat_type);
1617 if (rv != CONNECTION_ERROR_NONE)
1620 CONNECTION_LOG(CONNECTION_INFO, "connection_reset_statistics success");
1622 return CONNECTION_ERROR_NONE;
1625 EXPORT_API int connection_get_statistics(connection_h connection,
1626 connection_type_e connection_type,
1627 connection_statistics_type_e statistics_type, long long* size)
1631 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1633 if (connection_type == CONNECTION_TYPE_CELLULAR)
1634 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1635 else if (connection_type == CONNECTION_TYPE_WIFI)
1636 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1638 if (!(__connection_check_handle_validity(connection)) || size == NULL) {
1639 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1641 return CONNECTION_ERROR_INVALID_PARAMETER;
1644 int rv = __get_statistic(connection, connection_type, statistics_type, size);
1645 if (rv != CONNECTION_ERROR_NONE) {
1646 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get statistics [%d]", rv); //LCOV_EXCL_LINE
1648 return rv; //LCOV_EXCL_LINE
1652 return CONNECTION_ERROR_NONE;
1655 EXPORT_API int connection_reset_statistics(connection_h connection,
1656 connection_type_e connection_type,
1657 connection_statistics_type_e statistics_type)
1661 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1663 if (connection_type == CONNECTION_TYPE_CELLULAR)
1664 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1665 else if (connection_type == CONNECTION_TYPE_WIFI)
1666 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1668 if (!__connection_check_handle_validity(connection)) {
1669 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1671 return CONNECTION_ERROR_INVALID_PARAMETER;
1674 int rv = __reset_statistic(connection, connection_type, statistics_type);
1675 if (rv != CONNECTION_ERROR_NONE) {
1676 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get statistics [%d]", rv); //LCOV_EXCL_LINE
1678 return rv; //LCOV_EXCL_LINE
1682 return CONNECTION_ERROR_NONE;
1685 EXPORT_API int connection_foreach_ipv6_address(connection_h connection,
1686 connection_type_e connection_type, connection_ipv6_address_cb callback,
1691 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1692 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1694 GSList *ipv6_address_list = NULL;
1696 if (!(__connection_check_handle_validity(connection))) {
1697 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1699 return CONNECTION_ERROR_INVALID_PARAMETER;
1702 int rv = CONNECTION_ERROR_NONE;
1704 switch (connection_type) {
1705 case CONNECTION_TYPE_WIFI:
1706 rv = net_foreach_ipv6_address(NET_DEVICE_WIFI,
1707 &ipv6_address_list);
1709 case CONNECTION_TYPE_CELLULAR:
1710 rv = net_foreach_ipv6_address(NET_DEVICE_CELLULAR,
1711 &ipv6_address_list);
1713 case CONNECTION_TYPE_ETHERNET:
1714 rv = net_foreach_ipv6_address(NET_DEVICE_ETHERNET,
1715 &ipv6_address_list);
1717 case CONNECTION_TYPE_BT:
1718 rv = net_foreach_ipv6_address(NET_DEVICE_BLUETOOTH,
1719 &ipv6_address_list);
1722 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1724 return CONNECTION_ERROR_INVALID_PARAMETER;
1727 if (rv != NET_ERR_NONE) {
1728 CONNECTION_LOG(CONNECTION_ERROR, "net_get_multiple_id_address"
1729 " Failed = %d\n", rv);
1731 return CONNECTION_ERROR_OPERATION_FAILED;
1735 for (list = ipv6_address_list; list; list = list->next) {
1736 rv = callback((char *)list->data, user_data);
1741 g_slist_free_full(ipv6_address_list, g_free);
1742 ipv6_address_list = NULL;
1745 return CONNECTION_ERROR_NONE;
1748 EXPORT_API int connection_profile_start_tcpdump(connection_h connection)
1754 if (!(__connection_check_handle_validity(connection))) {
1755 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1757 return CONNECTION_ERROR_INVALID_PARAMETER;
1760 ret = _connection_libnet_start_tcpdump(connection);
1761 if (ret != CONNECTION_ERROR_NONE) {
1762 CONNECTION_LOG(CONNECTION_ERROR, "Failed to start tcpdump (%d)", ret);
1768 return CONNECTION_ERROR_NONE;
1771 EXPORT_API int connection_profile_stop_tcpdump(connection_h connection)
1777 if (!(__connection_check_handle_validity(connection))) {
1778 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1780 return CONNECTION_ERROR_INVALID_PARAMETER;
1783 ret = _connection_libnet_stop_tcpdump(connection);
1784 if (ret != CONNECTION_ERROR_NONE) {
1785 CONNECTION_LOG(CONNECTION_ERROR, "Failed to stop tcpdump (%d)", ret);
1791 return CONNECTION_ERROR_NONE;
1794 EXPORT_API int connection_profile_get_tcpdump_state(connection_h connection, gboolean *tcpdump_state)
1800 if (!(__connection_check_handle_validity(connection)) || !tcpdump_state) {
1801 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1803 return CONNECTION_ERROR_INVALID_PARAMETER;
1806 ret = _connection_libnet_get_tcpdump_state(connection, tcpdump_state);
1807 if (ret != CONNECTION_ERROR_NONE) {
1808 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get the tcpdump state (%d)", ret);
1814 return CONNECTION_ERROR_NONE;