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_ethernet_cable_state_changed_cb(connection_handle_s *conn_handle,
104 void *callback, void *user_data)
106 conn_handle->ethernet_cable_state_changed_callback = callback;
107 conn_handle->ethernet_cable_state_changed_user_data = user_data;
110 static void __connection_set_default_cellular_service_profile_callback(connection_handle_s *conn_handle,
111 void *callback, void *user_data)
113 conn_handle->set_default_callback = callback;
114 conn_handle->set_default_user_data = user_data;
117 static void __connection_open_profile_set_callback(connection_handle_s *conn_handle,
118 void *callback, void *user_data)
120 conn_handle->opened_callback = callback;
121 conn_handle->opened_user_data = user_data;
124 static void __connection_close_profile_set_callback(connection_handle_s *conn_handle,
125 void *callback, void *user_data)
127 conn_handle->closed_callback = callback;
128 conn_handle->closed_user_data = user_data;
131 static void __connection_reset_profile_set_callback(connection_handle_s *conn_handle,
132 void *callback, void *user_data)
134 conn_handle->reset_callback = callback;
135 conn_handle->reset_user_data = user_data;
139 /* Connection Manager ********************************************************/
140 EXPORT_API int connection_create(connection_h *connection)
144 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
148 if (connection == NULL || __connection_check_handle_validity(*connection)) {
149 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
151 return CONNECTION_ERROR_INVALID_PARAMETER;
154 *connection = g_try_malloc0(sizeof(connection_handle_s));
155 if (*connection != NULL) {
156 CONNECTION_LOG(CONNECTION_INFO, "New handle created[%p]", *connection);
159 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
162 rv = _connection_libnet_init(*connection);
163 if (rv == NET_ERR_ACCESS_DENIED) {
164 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
166 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
167 } else if (rv != NET_ERR_NONE) {
168 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create connection[%d]", rv); //LCOV_EXCL_LINE
170 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
173 conn_handle_list = g_slist_prepend(conn_handle_list, *connection);
176 return CONNECTION_ERROR_NONE;
179 EXPORT_API int connection_destroy(connection_h connection)
183 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
185 if (!(__connection_check_handle_validity(connection))) {
186 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
188 return CONNECTION_ERROR_INVALID_PARAMETER;
191 CONNECTION_LOG(CONNECTION_INFO, "Destroy handle: %p", connection);
193 __connection_set_type_changed_callback(connection, NULL, NULL);
194 __connection_set_ip_changed_callback(connection, NULL, NULL);
195 __connection_set_proxy_changed_callback(connection, NULL, NULL);
196 __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
197 _connection_libnet_deinit(connection);
199 conn_handle_list = g_slist_remove(conn_handle_list, connection);
205 return CONNECTION_ERROR_NONE;
208 EXPORT_API int connection_create_cs(int tid, connection_h *connection)
212 rv = connection_create(connection);
213 if (rv == CONNECTION_ERROR_NONE) {
215 _connection_set_cs_tid(tid, *connection);
222 EXPORT_API int connection_destroy_cs(int tid, connection_h connection)
227 _connection_unset_cs_tid(tid, connection);
230 rv = connection_destroy(connection);
235 EXPORT_API int connection_get_type(connection_h connection, connection_type_e* type)
242 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
244 if (type == NULL || !(__connection_check_handle_validity(connection))) {
245 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
247 return CONNECTION_ERROR_INVALID_PARAMETER;
250 rv = vconf_get_int(VCONFKEY_NETWORK_STATUS, &status);
251 if (rv != VCONF_OK) {
252 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed = %d", status); //LCOV_EXCL_LINE
254 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
257 CONNECTION_LOG(CONNECTION_INFO, "Connected Network = %d", status);
259 *type = __connection_convert_net_state(status);
262 return CONNECTION_ERROR_NONE;
265 EXPORT_API int connection_get_ip_address(connection_h connection,
266 connection_address_family_e address_family, char** ip_address)
270 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
272 if (ip_address == NULL || !(__connection_check_handle_validity(connection))) {
273 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
275 return CONNECTION_ERROR_INVALID_PARAMETER;
278 switch (address_family) {
279 case CONNECTION_ADDRESS_FAMILY_IPV4:
280 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP);
282 case CONNECTION_ADDRESS_FAMILY_IPV6:
283 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP6);
286 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
288 return CONNECTION_ERROR_INVALID_PARAMETER;
291 if (*ip_address == NULL) {
292 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
294 return CONNECTION_ERROR_OPERATION_FAILED;//LCOV_EXCL_LINE
298 return CONNECTION_ERROR_NONE;
301 EXPORT_API int connection_get_proxy(connection_h connection,
302 connection_address_family_e address_family, char** proxy)
306 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
308 if (proxy == NULL || !(__connection_check_handle_validity(connection))) {
309 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
311 return CONNECTION_ERROR_INVALID_PARAMETER;
314 switch (address_family) {
315 case CONNECTION_ADDRESS_FAMILY_IPV4:
316 case CONNECTION_ADDRESS_FAMILY_IPV6:
317 *proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
320 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
322 return CONNECTION_ERROR_INVALID_PARAMETER;
325 if (*proxy == NULL) {
326 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
328 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
332 return CONNECTION_ERROR_NONE;
335 EXPORT_API int connection_get_mac_address(connection_h connection, connection_type_e type, char** mac_addr)
338 char buf[CONNECTION_MAC_INFO_LENGTH + 1];
342 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE, ETHERNET_FEATURE);
344 if (type == CONNECTION_TYPE_WIFI)
345 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
346 else if (type == CONNECTION_TYPE_ETHERNET) //LCOV_EXCL_LINE
347 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE); //LCOV_EXCL_LINE
349 if (mac_addr == NULL || !(__connection_check_handle_validity(connection))) {
350 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
352 return CONNECTION_ERROR_INVALID_PARAMETER;
356 case CONNECTION_TYPE_WIFI:
357 if (__builtin_expect(tv_profile == -1, 0)) {
359 system_info_get_platform_string("http://tizen.org/feature/profile", &profileName);
360 if (*profileName == 't' || *profileName == 'T')
366 if (tv_profile == 1) {
367 fp = fopen(WIFI_MAC_INFO_FILE, "r");
369 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", WIFI_MAC_INFO_FILE); //LCOV_EXCL_LINE
371 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
374 if (fgets(buf, sizeof(buf), fp) == NULL) {
375 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", WIFI_MAC_INFO_FILE); //LCOV_EXCL_LINE
376 fclose(fp); //LCOV_EXCL_LINE
378 return CONNECTION_ERROR_OPERATION_FAILED;
381 CONNECTION_LOG(CONNECTION_INFO, "%s : %s", WIFI_MAC_INFO_FILE, buf);
383 *mac_addr = (char *)malloc(CONNECTION_MAC_INFO_LENGTH + 1);
384 if (*mac_addr == NULL) {
385 CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed"); //LCOV_EXCL_LINE
386 fclose(fp); //LCOV_EXCL_LINE
388 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
390 g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1);
393 *mac_addr = vconf_get_str(VCONFKEY_WIFI_BSSID_ADDRESS);
395 if (*mac_addr == NULL) {
396 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get vconf from %s", VCONFKEY_WIFI_BSSID_ADDRESS); //LCOV_EXCL_LINE
398 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
403 case CONNECTION_TYPE_ETHERNET:
404 fp = fopen(ETHERNET_MAC_INFO_FILE, "r");
406 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", ETHERNET_MAC_INFO_FILE);
408 return CONNECTION_ERROR_OUT_OF_MEMORY;
411 if (fgets(buf, sizeof(buf), fp) == NULL) {
412 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", ETHERNET_MAC_INFO_FILE);
415 return CONNECTION_ERROR_OPERATION_FAILED;
418 CONNECTION_LOG(CONNECTION_INFO, "%s : %s", ETHERNET_MAC_INFO_FILE, buf);
420 *mac_addr = (char *)malloc(CONNECTION_MAC_INFO_LENGTH + 1);
421 if (*mac_addr == NULL) {
422 CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed");
425 return CONNECTION_ERROR_OUT_OF_MEMORY;
428 g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1);
434 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
436 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
439 /* Checking Invalid MAC Address */
440 if ((strcmp(*mac_addr, "00:00:00:00:00:00") == 0) ||
441 (strcmp(*mac_addr, "ff:ff:ff:ff:ff:ff") == 0)) {
442 CONNECTION_LOG(CONNECTION_ERROR, "MAC Address(%s) is invalid", *mac_addr); //LCOV_EXCL_LINE
444 return CONNECTION_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
447 CONNECTION_LOG(CONNECTION_INFO, "MAC Address %s", *mac_addr);
450 return CONNECTION_ERROR_NONE;
454 EXPORT_API int connection_is_metered_network(connection_h connection, bool* is_metered)
458 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
460 if (is_metered == NULL || !(__connection_check_handle_validity(connection))) {
461 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
463 return CONNECTION_ERROR_INVALID_PARAMETER;
466 int rv = _connection_libnet_get_metered_state(connection, is_metered);
467 if (rv != CONNECTION_ERROR_NONE) {
468 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get metered state[%d]", rv); //LCOV_EXCL_LINE
470 return rv; //LCOV_EXCL_LINE
473 CONNECTION_LOG(CONNECTION_INFO, "metered state: %s", is_metered ? "true" : "false");
475 return CONNECTION_ERROR_NONE;
479 EXPORT_API int connection_get_cellular_state(connection_h connection, connection_cellular_state_e* state)
483 int cellular_state = 0;
484 #if defined TIZEN_DUALSIM_ENABLE
490 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
492 if (state == NULL || !(__connection_check_handle_validity(connection))) {
493 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
495 return CONNECTION_ERROR_INVALID_PARAMETER;
498 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &status);
499 if (rv != VCONF_OK) {
500 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
502 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
505 CONNECTION_LOG(CONNECTION_INFO, "Cellular: %d", status);
506 *state = __connection_convert_cellular_state(status);
508 if (*state == CONNECTION_CELLULAR_STATE_AVAILABLE) {
509 #if defined TIZEN_DUALSIM_ENABLE
510 rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
511 if (rv != VCONF_OK) {
512 CONNECTION_LOG(CONNECTION_ERROR,
513 "Failed to get default subscriber id", sim_id);
515 return CONNECTION_ERROR_OPERATION_FAILED;
519 case CONNECTION_CELLULAR_SUBSCRIBER_1:
521 rv = vconf_get_int(VCONFKEY_DNET_STATE, &cellular_state);
522 #if defined TIZEN_DUALSIM_ENABLE
525 case CONNECTION_CELLULAR_SUBSCRIBER_2:
526 rv = vconf_get_int(VCONFKEY_DNET_STATE2, &cellular_state);
530 CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
532 return CONNECTION_ERROR_OPERATION_FAILED;
535 if (rv != VCONF_OK) {
536 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
538 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
542 CONNECTION_LOG(CONNECTION_INFO, "Cellular state: %d", cellular_state);
544 if (cellular_state == VCONFKEY_DNET_NORMAL_CONNECTED ||
545 cellular_state == VCONFKEY_DNET_SECURE_CONNECTED ||
546 cellular_state == VCONFKEY_DNET_TRANSFER)
547 *state = CONNECTION_CELLULAR_STATE_CONNECTED;
550 return CONNECTION_ERROR_NONE;
553 EXPORT_API int connection_get_wifi_state(connection_h connection, connection_wifi_state_e* state)
557 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
559 if (state == NULL || !(__connection_check_handle_validity(connection))) {
560 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
562 return CONNECTION_ERROR_INVALID_PARAMETER;
565 int rv = _connection_libnet_get_wifi_state(connection, state);
566 if (rv != CONNECTION_ERROR_NONE) {
567 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get Wi-Fi state[%d]", rv); //LCOV_EXCL_LINE
569 return rv; //LCOV_EXCL_LINE
572 CONNECTION_LOG(CONNECTION_INFO, "Wi-Fi state: %d", *state);
575 return CONNECTION_ERROR_NONE;
579 EXPORT_API int connection_get_ethernet_state(connection_h connection, connection_ethernet_state_e *state)
583 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
585 if (state == NULL || !(__connection_check_handle_validity(connection))) {
586 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
588 return CONNECTION_ERROR_INVALID_PARAMETER;
591 int rv = _connection_libnet_get_ethernet_state(connection, state);
592 if (rv != CONNECTION_ERROR_NONE) {
593 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get ethernet state[%d]", rv); //LCOV_EXCL_LINE
595 return rv; //LCOV_EXCL_LINE
599 return CONNECTION_ERROR_NONE;
602 EXPORT_API int connection_get_ethernet_cable_state(connection_h connection, connection_ethernet_cable_state_e *state)
606 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
608 if (state == NULL || !(__connection_check_handle_validity(connection))) {
609 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
611 return CONNECTION_ERROR_INVALID_PARAMETER;
614 int rv = _connection_libnet_get_ethernet_cable_state(connection, state);
615 if (rv != CONNECTION_ERROR_NONE) {
616 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get ethernet cable state[%d]", rv); //LCOV_EXCL_LINE
618 return rv; //LCOV_EXCL_LINE
622 return CONNECTION_ERROR_NONE;
625 EXPORT_API int connection_set_ethernet_cable_state_chaged_cb(connection_h connection,
626 connection_ethernet_cable_state_chaged_cb callback, void *user_data)
628 DEPRECATED_LOG(__FUNCTION__, "connection_set_ethernet_cable_state_changed_cb");
632 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
634 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
635 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
637 return CONNECTION_ERROR_INVALID_PARAMETER;
640 DEPRECATED_LOG("connection_ethernet_cable_state_chaged_cb",
641 "connection_ethernet_cable_state_changed_cb");
643 __connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data);
646 return CONNECTION_ERROR_NONE;
649 EXPORT_API int connection_unset_ethernet_cable_state_chaged_cb(connection_h connection)
651 DEPRECATED_LOG(__FUNCTION__, "connection_unset_ethernet_cable_state_changed_cb");
655 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
657 if (!(__connection_check_handle_validity(connection))) {
658 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
660 return CONNECTION_ERROR_INVALID_PARAMETER;
663 __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
666 return CONNECTION_ERROR_NONE;
669 EXPORT_API int connection_set_ethernet_cable_state_changed_cb(connection_h connection,
670 connection_ethernet_cable_state_changed_cb callback, void *user_data)
674 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
676 if (callback == NULL || !(__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, callback, user_data);
685 return CONNECTION_ERROR_NONE;
688 EXPORT_API int connection_unset_ethernet_cable_state_changed_cb(connection_h connection)
692 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
694 if (!(__connection_check_handle_validity(connection))) {
695 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
697 return CONNECTION_ERROR_INVALID_PARAMETER;
700 __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
703 return CONNECTION_ERROR_NONE;
707 EXPORT_API int connection_get_bt_state(connection_h connection, connection_bt_state_e *state)
711 CHECK_FEATURE_SUPPORTED(TETHERING_BLUETOOTH_FEATURE);
713 if (state == NULL || !(__connection_check_handle_validity(connection))) {
714 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
716 return CONNECTION_ERROR_INVALID_PARAMETER;
719 int rv = _connection_libnet_get_bluetooth_state(connection, state);
720 if (rv != CONNECTION_ERROR_NONE) {
721 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get bluetooth state[%d]", rv); //LCOV_EXCL_LINE
723 return rv; //LCOV_EXCL_LINE
727 return CONNECTION_ERROR_NONE;
730 EXPORT_API int connection_set_type_changed_cb(connection_h connection,
731 connection_type_changed_cb callback, void* user_data)
735 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
737 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
738 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
740 return CONNECTION_ERROR_INVALID_PARAMETER;
743 __connection_set_type_changed_callback(connection, callback, user_data);
746 return CONNECTION_ERROR_NONE;
749 EXPORT_API int connection_unset_type_changed_cb(connection_h connection)
753 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
755 if (!(__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, NULL, NULL);
764 return CONNECTION_ERROR_NONE;
767 EXPORT_API int connection_set_ip_address_changed_cb(connection_h connection,
768 connection_address_changed_cb callback, void* user_data)
772 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
774 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
775 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
777 return CONNECTION_ERROR_INVALID_PARAMETER;
780 __connection_set_ip_changed_callback(connection, callback, user_data);
783 return CONNECTION_ERROR_NONE;
786 EXPORT_API int connection_unset_ip_address_changed_cb(connection_h connection)
790 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
792 if (!(__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, NULL, NULL);
801 return CONNECTION_ERROR_NONE;
804 EXPORT_API int connection_set_proxy_address_changed_cb(connection_h connection,
805 connection_address_changed_cb callback, void* user_data)
809 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
811 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
812 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
814 return CONNECTION_ERROR_INVALID_PARAMETER;
817 __connection_set_proxy_changed_callback(connection, callback, user_data);
820 return CONNECTION_ERROR_NONE;
823 EXPORT_API int connection_unset_proxy_address_changed_cb(connection_h connection)
827 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
829 if (!(__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, NULL, NULL);
838 return CONNECTION_ERROR_NONE;
841 EXPORT_API int connection_add_profile(connection_h connection, connection_profile_h profile)
844 connection_handle_s *conn_handle = (connection_handle_s *)connection;
845 net_profile_info_t *profile_info = (net_profile_info_t *)profile;
849 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
851 if (!(__connection_check_handle_validity(connection)) ||
852 !(_connection_libnet_check_profile_validity(profile))) {
853 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
855 return CONNECTION_ERROR_INVALID_PARAMETER;
858 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
859 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
861 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
864 if (profile_info->ProfileInfo.Pdp.PSModemPath[0] != '/' ||
865 strlen(profile_info->ProfileInfo.Pdp.PSModemPath) < 2) {
866 CONNECTION_LOG(CONNECTION_ERROR, "Modem object path is NULL"); //LCOV_EXCL_LINE
868 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
871 rv = net_add_profile(conn_handle->network_info_handle,
872 profile_info->ProfileInfo.Pdp.ServiceType, profile_info);
873 if (rv == NET_ERR_ACCESS_DENIED) {
874 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
876 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
877 } else if (rv != NET_ERR_NONE) {
878 CONNECTION_LOG(CONNECTION_ERROR, "Failed to add profile[%d]", rv); //LCOV_EXCL_LINE
880 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
884 return CONNECTION_ERROR_NONE;
887 EXPORT_API int connection_remove_profile(connection_h connection, connection_profile_h profile)
890 connection_handle_s *conn_handle = (connection_handle_s *)connection;
891 net_profile_info_t *profile_info = (net_profile_info_t *)profile;
895 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
897 if (!(__connection_check_handle_validity(connection)) ||
898 !(_connection_libnet_check_profile_validity(profile))) {
899 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
901 return CONNECTION_ERROR_INVALID_PARAMETER;
904 if (profile_info->profile_type != NET_DEVICE_CELLULAR &&
905 profile_info->profile_type != NET_DEVICE_MESH &&
906 profile_info->profile_type != NET_DEVICE_WIFI) {
907 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
909 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
912 rv = net_delete_profile(conn_handle->network_info_handle, profile_info->ProfileName);
913 if (rv == NET_ERR_ACCESS_DENIED) {
914 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
916 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
917 } else if (rv != NET_ERR_NONE) {
918 CONNECTION_LOG(CONNECTION_ERROR, "Failed to delete profile[%d]", rv); //LCOV_EXCL_LINE
920 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
924 return CONNECTION_ERROR_NONE;
927 EXPORT_API int connection_update_profile(connection_h connection, connection_profile_h profile)
930 connection_handle_s *conn_handle = (connection_handle_s *)connection;
931 net_profile_info_t *profile_info = (net_profile_info_t *)profile;
935 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
937 if (!(__connection_check_handle_validity(connection)) ||
938 !(_connection_libnet_check_profile_validity(profile))) {
939 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
941 return CONNECTION_ERROR_INVALID_PARAMETER;
944 rv = net_modify_profile(conn_handle->network_info_handle,
945 profile_info->ProfileName, (net_profile_info_t*)profile);
946 if (rv == NET_ERR_ACCESS_DENIED) {
947 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
949 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
950 } else if (rv != NET_ERR_NONE) {
951 CONNECTION_LOG(CONNECTION_ERROR, "Failed to modify profile[%d]", rv); //LCOV_EXCL_LINE
953 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
957 return CONNECTION_ERROR_NONE;
960 EXPORT_API int connection_get_profile_iterator(connection_h connection,
961 connection_iterator_type_e type, connection_profile_iterator_h* profile_iterator)
965 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
967 if (!(__connection_check_handle_validity(connection)) ||
968 (type != CONNECTION_ITERATOR_TYPE_REGISTERED &&
969 type != CONNECTION_ITERATOR_TYPE_CONNECTED &&
970 type != CONNECTION_ITERATOR_TYPE_DEFAULT)) {
971 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
973 return CONNECTION_ERROR_INVALID_PARAMETER;
976 int rv = _connection_libnet_get_profile_iterator(connection, type, profile_iterator);
977 if (rv != CONNECTION_ERROR_NONE) {
978 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get profile iterator [%d]", rv); //LCOV_EXCL_LINE
980 return rv; //LCOV_EXCL_LINE
984 return CONNECTION_ERROR_NONE;
987 EXPORT_API int connection_profile_iterator_next(connection_profile_iterator_h profile_iterator,
988 connection_profile_h* profile)
992 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
994 int rv = _connection_libnet_get_iterator_next(profile_iterator, profile);
1000 EXPORT_API bool connection_profile_iterator_has_next(connection_profile_iterator_h profile_iterator)
1004 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1006 int rv = _connection_libnet_iterator_has_next(profile_iterator);
1012 EXPORT_API int connection_destroy_profile_iterator(connection_profile_iterator_h profile_iterator)
1016 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1018 int rv = _connection_libnet_destroy_iterator(profile_iterator);
1024 EXPORT_API int connection_get_current_profile(connection_h connection, connection_profile_h* profile)
1028 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1030 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1031 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1033 return CONNECTION_ERROR_INVALID_PARAMETER;
1036 int rv = _connection_libnet_get_current_profile(connection, profile);
1037 if (rv != CONNECTION_ERROR_NONE) {
1038 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get current profile [%d]", rv); //LCOV_EXCL_LINE
1040 return rv; //LCOV_EXCL_LINE
1044 return CONNECTION_ERROR_NONE;
1047 EXPORT_API int connection_get_default_cellular_service_profile(
1048 connection_h connection, connection_cellular_service_type_e type,
1049 connection_profile_h *profile)
1053 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1055 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1056 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1058 return CONNECTION_ERROR_INVALID_PARAMETER;
1061 int rv = _connection_libnet_get_cellular_service_profile(connection, type, profile);
1062 if (rv != CONNECTION_ERROR_NONE) {
1063 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get default cellular service profile [%d]", rv); //LCOV_EXCL_LINE
1065 return rv; //LCOV_EXCL_LINE
1069 return CONNECTION_ERROR_NONE;
1072 EXPORT_API int connection_set_default_cellular_service_profile(connection_h connection,
1073 connection_cellular_service_type_e type, connection_profile_h profile)
1077 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1079 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1080 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1082 return CONNECTION_ERROR_INVALID_PARAMETER;
1085 int rv = _connection_libnet_set_cellular_service_profile_sync(connection, type, profile);
1086 if (rv != CONNECTION_ERROR_NONE) {
1087 CONNECTION_LOG(CONNECTION_ERROR, "Fail to set default cellular service profile [%d]", rv); //LCOV_EXCL_LINE
1089 return rv; //LCOV_EXCL_LINE
1093 return CONNECTION_ERROR_NONE;
1096 EXPORT_API int connection_set_default_cellular_service_profile_async(connection_h connection,
1097 connection_cellular_service_type_e type, connection_profile_h profile,
1098 connection_set_default_cb callback, void* user_data)
1102 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1106 if (!(__connection_check_handle_validity(connection)) ||
1107 profile == NULL || callback == NULL) {
1108 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1110 return CONNECTION_ERROR_INVALID_PARAMETER;
1113 rv = _connection_libnet_set_cellular_service_profile_async(connection, type, profile);
1114 if (rv == NET_ERR_ACCESS_DENIED) {
1115 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1117 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1118 } else if (rv != NET_ERR_NONE) {
1119 CONNECTION_LOG(CONNECTION_ERROR, "Failed to set default cellular service profile[%d]", rv); //LCOV_EXCL_LINE
1121 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1124 __connection_set_default_cellular_service_profile_callback(connection, callback, user_data);
1127 return CONNECTION_ERROR_NONE;
1130 EXPORT_API int connection_open_profile(connection_h connection, connection_profile_h profile,
1131 connection_opened_cb callback, void* user_data)
1135 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1139 if (!(__connection_check_handle_validity(connection)) ||
1140 profile == NULL || callback == NULL) {
1141 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1143 return CONNECTION_ERROR_INVALID_PARAMETER;
1146 rv = _connection_libnet_open_profile(connection, profile);
1147 if (rv == NET_ERR_ACCESS_DENIED) {
1148 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1150 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1151 } else if (rv != NET_ERR_NONE) {
1152 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open profile[%d]", rv); //LCOV_EXCL_LINE
1154 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1157 __connection_open_profile_set_callback(connection, callback, user_data);
1160 return CONNECTION_ERROR_NONE;
1163 EXPORT_API int connection_close_profile(connection_h connection, connection_profile_h profile,
1164 connection_closed_cb callback, void* user_data)
1168 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1172 if (!(__connection_check_handle_validity(connection)) ||
1173 profile == NULL || callback == NULL) {
1174 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1176 return CONNECTION_ERROR_INVALID_PARAMETER;
1179 rv = _connection_libnet_close_profile(connection, profile);
1180 if (rv == NET_ERR_ACCESS_DENIED) {
1181 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1183 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1184 } else if (rv != NET_ERR_NONE) {
1185 CONNECTION_LOG(CONNECTION_ERROR, "Failed to close profile[%d]", rv); //LCOV_EXCL_LINE
1187 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1190 __connection_close_profile_set_callback(connection, callback, user_data);
1193 return CONNECTION_ERROR_NONE;
1196 EXPORT_API int connection_reset_profile(connection_h connection,
1197 connection_reset_option_e type, int id, connection_reset_cb callback, void *user_data)
1201 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1205 if (!(__connection_check_handle_validity(connection))) {
1206 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
1208 return CONNECTION_ERROR_INVALID_PARAMETER;
1211 if (id < 0 || id > 1) {
1212 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed"); //LCOV_EXCL_LINE
1214 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1217 rv = _connection_libnet_reset_profile(connection, type, id);
1218 if (rv == NET_ERR_ACCESS_DENIED) {
1219 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1221 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1222 } else if (rv != NET_ERR_NONE) {
1223 CONNECTION_LOG(CONNECTION_ERROR, "Failed to reset profile[%d]", rv); //LCOV_EXCL_LINE
1225 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1228 __connection_reset_profile_set_callback(connection, callback, user_data);
1231 return CONNECTION_ERROR_NONE;
1234 EXPORT_API int connection_add_route(connection_h connection, const char* interface_name, const char* host_address)
1238 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1240 if (!(__connection_check_handle_validity(connection)) ||
1241 interface_name == NULL || host_address == NULL) {
1242 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1244 return CONNECTION_ERROR_INVALID_PARAMETER;
1247 int rv = _connection_libnet_add_route(connection, interface_name, host_address);
1248 if (rv != CONNECTION_ERROR_NONE) {
1249 CONNECTION_LOG(CONNECTION_ERROR, "Fail to add route [%d]", rv); //LCOV_EXCL_LINE
1251 return rv; //LCOV_EXCL_LINE
1255 return CONNECTION_ERROR_NONE;
1258 EXPORT_API int connection_remove_route(connection_h connection, const char* interface_name, const char* host_address)
1262 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1264 if (!(__connection_check_handle_validity(connection)) ||
1265 interface_name == NULL || host_address == NULL) {
1266 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1268 return CONNECTION_ERROR_INVALID_PARAMETER;
1271 int rv = _connection_libnet_remove_route(connection, interface_name, host_address);
1272 if (rv != CONNECTION_ERROR_NONE) {
1273 CONNECTION_LOG(CONNECTION_ERROR, "Fail to remove route [%d]", rv); //LCOV_EXCL_LINE
1275 return rv; //LCOV_EXCL_LINE
1279 return CONNECTION_ERROR_NONE;
1282 EXPORT_API int connection_add_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1286 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1288 if (!(__connection_check_handle_validity(connection)) ||
1289 interface_name == NULL || host_address == NULL) {
1290 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1292 return CONNECTION_ERROR_INVALID_PARAMETER;
1295 int rv = _connection_libnet_add_route_ipv6(connection, interface_name, host_address, gateway);
1296 if (rv != CONNECTION_ERROR_NONE) {
1297 CONNECTION_LOG(CONNECTION_ERROR, "Fail to add route ipv6 [%d]", rv); //LCOV_EXCL_LINE
1299 return rv; //LCOV_EXCL_LINE
1303 return CONNECTION_ERROR_NONE;
1306 EXPORT_API int connection_remove_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1310 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1312 if (!(__connection_check_handle_validity(connection)) ||
1313 interface_name == NULL || host_address == NULL) {
1314 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1316 return CONNECTION_ERROR_INVALID_PARAMETER;
1319 int rv = _connection_libnet_remove_route_ipv6(connection, interface_name, host_address, gateway);
1320 if (rv != CONNECTION_ERROR_NONE) {
1321 CONNECTION_LOG(CONNECTION_ERROR, "Fail to remove route ipv6 [%d]", rv); //LCOV_EXCL_LINE
1323 return rv; //LCOV_EXCL_LINE
1327 return CONNECTION_ERROR_NONE;
1330 EXPORT_API int connection_add_route_entry(connection_h connection,
1331 connection_address_family_e address_family, const char *interface_name,
1332 const char *host_address, const char *gateway)
1336 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1338 if (!(__connection_check_handle_validity(connection)) ||
1339 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1340 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1341 interface_name == NULL || host_address == NULL) {
1342 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1344 return CONNECTION_ERROR_INVALID_PARAMETER;
1347 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1348 int rv = _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
1349 interface_name, host_address, gateway);
1353 int rv = _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
1354 interface_name, host_address, gateway);
1360 return CONNECTION_ERROR_NONE;
1363 EXPORT_API int connection_remove_route_entry(connection_h connection,
1364 connection_address_family_e address_family, const char *interface_name,
1365 const char *host_address, const char *gateway)
1369 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1371 if (!(__connection_check_handle_validity(connection)) ||
1372 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1373 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1374 interface_name == NULL || host_address == NULL) {
1375 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1377 return CONNECTION_ERROR_INVALID_PARAMETER;
1380 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1381 int rv = _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
1382 interface_name, host_address, gateway);
1386 int rv = _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
1387 interface_name, host_address, gateway);
1393 return CONNECTION_ERROR_NONE;
1396 static int __get_cellular_statistic(connection_statistics_type_e statistics_type, long long *llsize)
1398 int rv = VCONF_OK, rv1 = VCONF_OK;
1399 int last_size = 0, size = 0;
1400 #if defined TIZEN_DUALSIM_ENABLE
1404 if (llsize == NULL) {
1405 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1406 return CONNECTION_ERROR_INVALID_PARAMETER;
1409 switch (statistics_type) {
1410 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1411 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1412 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1413 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1416 return CONNECTION_ERROR_INVALID_PARAMETER;
1419 #if defined TIZEN_DUALSIM_ENABLE
1420 rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
1421 if (rv != VCONF_OK) {
1422 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get default subscriber id");
1424 return CONNECTION_ERROR_OPERATION_FAILED;
1430 switch (statistics_type) {
1431 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1432 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1434 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1435 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1437 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1438 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1439 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT, &size);
1441 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1442 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1443 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV, &size);
1446 #if defined TIZEN_DUALSIM_ENABLE
1449 switch (statistics_type) {
1450 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1451 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1453 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1454 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1456 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1457 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1458 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT2, &size);
1460 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1461 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1462 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV2, &size);
1468 CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
1469 return CONNECTION_ERROR_OPERATION_FAILED;
1473 if (rv != VCONF_OK || rv1 != VCONF_OK) {
1474 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular statistics"); //LCOV_EXCL_LINE
1475 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1478 *llsize = (long long)(last_size * 1000) + (long long)(size * 1000);
1479 CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", *llsize);
1481 return CONNECTION_ERROR_NONE;
1484 static int __get_statistic(connection_handle_s *conn_handle, connection_type_e connection_type,
1485 connection_statistics_type_e statistics_type, long long *llsize)
1488 unsigned long long ull_size;
1490 if (llsize == NULL) {
1491 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1492 return CONNECTION_ERROR_INVALID_PARAMETER;
1495 rv = _connection_libnet_check_get_privilege();
1496 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1498 else if (rv != CONNECTION_ERROR_NONE) {
1499 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get statistics"); //LCOV_EXCL_LINE
1500 return CONNECTION_ERROR_OPERATION_FAILED;
1503 if (connection_type == CONNECTION_TYPE_CELLULAR)
1504 return __get_cellular_statistic(statistics_type, llsize);
1505 else if (connection_type == CONNECTION_TYPE_WIFI) {
1506 switch (statistics_type) {
1507 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1508 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1510 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1511 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1513 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1514 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1516 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1517 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1520 return CONNECTION_ERROR_INVALID_PARAMETER;
1523 rv = _connection_libnet_get_statistics(conn_handle, stat_type, &ull_size);
1524 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1526 else if (rv != CONNECTION_ERROR_NONE) {
1527 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get Wi-Fi statistics"); //LCOV_EXCL_LINE
1528 *llsize = 0; //LCOV_EXCL_LINE
1529 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1532 CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", ull_size);
1533 *llsize = (long long)ull_size;
1535 return CONNECTION_ERROR_INVALID_PARAMETER;
1537 return CONNECTION_ERROR_NONE;
1540 static int __reset_statistic(connection_handle_s *conn_handle,
1541 connection_type_e connection_type, connection_statistics_type_e statistics_type)
1547 if (connection_type == CONNECTION_TYPE_CELLULAR)
1548 conn_type = NET_DEVICE_CELLULAR;
1549 else if (connection_type == CONNECTION_TYPE_WIFI)
1550 conn_type = NET_DEVICE_WIFI;
1552 return CONNECTION_ERROR_INVALID_PARAMETER;
1554 switch (statistics_type) {
1555 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1556 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1558 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1559 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1561 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1562 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1564 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1565 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1568 return CONNECTION_ERROR_INVALID_PARAMETER;
1571 rv = _connection_libnet_set_statistics(conn_handle, conn_type, stat_type);
1572 if (rv != CONNECTION_ERROR_NONE)
1575 CONNECTION_LOG(CONNECTION_INFO, "connection_reset_statistics success");
1577 return CONNECTION_ERROR_NONE;
1580 EXPORT_API int connection_get_statistics(connection_h connection,
1581 connection_type_e connection_type,
1582 connection_statistics_type_e statistics_type, long long* size)
1586 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1588 if (connection_type == CONNECTION_TYPE_CELLULAR)
1589 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1590 else if (connection_type == CONNECTION_TYPE_WIFI)
1591 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1593 if (!(__connection_check_handle_validity(connection)) || size == NULL) {
1594 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1596 return CONNECTION_ERROR_INVALID_PARAMETER;
1599 int rv = __get_statistic(connection, connection_type, statistics_type, size);
1600 if (rv != CONNECTION_ERROR_NONE) {
1601 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get statistics [%d]", rv); //LCOV_EXCL_LINE
1603 return rv; //LCOV_EXCL_LINE
1607 return CONNECTION_ERROR_NONE;
1610 EXPORT_API int connection_reset_statistics(connection_h connection,
1611 connection_type_e connection_type,
1612 connection_statistics_type_e statistics_type)
1616 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1618 if (connection_type == CONNECTION_TYPE_CELLULAR)
1619 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1620 else if (connection_type == CONNECTION_TYPE_WIFI)
1621 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1623 if (!__connection_check_handle_validity(connection)) {
1624 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1626 return CONNECTION_ERROR_INVALID_PARAMETER;
1629 int rv = __reset_statistic(connection, connection_type, statistics_type);
1630 if (rv != CONNECTION_ERROR_NONE) {
1631 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get statistics [%d]", rv); //LCOV_EXCL_LINE
1633 return rv; //LCOV_EXCL_LINE
1637 return CONNECTION_ERROR_NONE;
1640 EXPORT_API int connection_foreach_ipv6_address(connection_h connection,
1641 connection_type_e connection_type, connection_ipv6_address_cb callback,
1646 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1647 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1649 GSList *ipv6_address_list = NULL;
1651 if (!(__connection_check_handle_validity(connection))) {
1652 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1654 return CONNECTION_ERROR_INVALID_PARAMETER;
1657 int rv = CONNECTION_ERROR_NONE;
1659 switch (connection_type) {
1660 case CONNECTION_TYPE_WIFI:
1661 rv = net_foreach_ipv6_address(NET_DEVICE_WIFI,
1662 &ipv6_address_list);
1664 case CONNECTION_TYPE_CELLULAR:
1665 rv = net_foreach_ipv6_address(NET_DEVICE_CELLULAR,
1666 &ipv6_address_list);
1668 case CONNECTION_TYPE_ETHERNET:
1669 rv = net_foreach_ipv6_address(NET_DEVICE_ETHERNET,
1670 &ipv6_address_list);
1672 case CONNECTION_TYPE_BT:
1673 rv = net_foreach_ipv6_address(NET_DEVICE_BLUETOOTH,
1674 &ipv6_address_list);
1677 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1679 return CONNECTION_ERROR_INVALID_PARAMETER;
1682 if (rv != NET_ERR_NONE) {
1683 CONNECTION_LOG(CONNECTION_ERROR, "net_get_multiple_id_address"
1684 " Failed = %d\n", rv);
1686 return CONNECTION_ERROR_OPERATION_FAILED;
1690 for (list = ipv6_address_list; list; list = list->next) {
1691 rv = callback((char *)list->data, user_data);
1696 g_slist_free_full(ipv6_address_list, g_free);
1697 ipv6_address_list = NULL;
1700 return CONNECTION_ERROR_NONE;
1703 EXPORT_API int connection_profile_start_tcpdump(connection_h connection)
1709 if (!(__connection_check_handle_validity(connection))) {
1710 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1712 return CONNECTION_ERROR_INVALID_PARAMETER;
1715 ret = _connection_libnet_start_tcpdump(connection);
1716 if (ret != CONNECTION_ERROR_NONE) {
1717 CONNECTION_LOG(CONNECTION_ERROR, "Failed to start tcpdump (%d)", ret);
1723 return CONNECTION_ERROR_NONE;
1726 EXPORT_API int connection_profile_stop_tcpdump(connection_h connection)
1732 if (!(__connection_check_handle_validity(connection))) {
1733 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1735 return CONNECTION_ERROR_INVALID_PARAMETER;
1738 ret = _connection_libnet_stop_tcpdump(connection);
1739 if (ret != CONNECTION_ERROR_NONE) {
1740 CONNECTION_LOG(CONNECTION_ERROR, "Failed to stop tcpdump (%d)", ret);
1746 return CONNECTION_ERROR_NONE;
1749 EXPORT_API int connection_profile_get_tcpdump_state(connection_h connection, gboolean *tcpdump_state)
1755 if (!(__connection_check_handle_validity(connection)) || !tcpdump_state) {
1756 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1758 return CONNECTION_ERROR_INVALID_PARAMETER;
1761 ret = _connection_libnet_get_tcpdump_state(connection, tcpdump_state);
1762 if (ret != CONNECTION_ERROR_NONE) {
1763 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get the tcpdump state (%d)", ret);
1769 return CONNECTION_ERROR_NONE;