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.
22 #include <vconf/vconf.h>
23 #include <system_info.h>
25 #include "net_connection_private.h"
27 static GSList *conn_handle_list = NULL;
30 static int __connection_convert_net_state(int status)
33 case VCONFKEY_NETWORK_CELLULAR:
34 return CONNECTION_TYPE_CELLULAR;
35 case VCONFKEY_NETWORK_WIFI:
36 return CONNECTION_TYPE_WIFI;
37 case VCONFKEY_NETWORK_ETHERNET:
38 return CONNECTION_TYPE_ETHERNET;
39 case VCONFKEY_NETWORK_BLUETOOTH:
40 return CONNECTION_TYPE_BT;
41 case VCONFKEY_NETWORK_DEFAULT_PROXY:
42 return CONNECTION_TYPE_NET_PROXY;
44 return CONNECTION_TYPE_DISCONNECTED;
48 static int __connection_convert_cellular_state(int status)
51 case VCONFKEY_NETWORK_CELLULAR_ON:
52 return CONNECTION_CELLULAR_STATE_AVAILABLE;
53 case VCONFKEY_NETWORK_CELLULAR_3G_OPTION_OFF:
54 return CONNECTION_CELLULAR_STATE_CALL_ONLY_AVAILABLE;
55 case VCONFKEY_NETWORK_CELLULAR_ROAMING_OFF:
56 return CONNECTION_CELLULAR_STATE_ROAMING_OFF;
57 case VCONFKEY_NETWORK_CELLULAR_FLIGHT_MODE:
58 return CONNECTION_CELLULAR_STATE_FLIGHT_MODE;
60 return CONNECTION_CELLULAR_STATE_OUT_OF_SERVICE;
64 static bool __connection_check_handle_validity(connection_h connection)
68 if (connection == NULL)
71 if (g_slist_find(conn_handle_list, connection) != NULL)
77 bool _connection_check_handle_validity(connection_h connection)
79 return __connection_check_handle_validity(connection);
82 static void __connection_set_type_changed_callback(connection_handle_s *conn_handle,
83 void *callback, void *user_data)
85 conn_handle->type_changed_user_data = user_data;
86 conn_handle->type_changed_callback = callback;
89 static void __connection_set_ip_changed_callback(connection_handle_s *conn_handle,
90 void *callback, void *user_data)
92 conn_handle->ip_changed_user_data = user_data;
93 conn_handle->ip_changed_callback = callback;
96 static void __connection_set_proxy_changed_callback(connection_handle_s *conn_handle,
97 void *callback, void *user_data)
99 conn_handle->proxy_changed_user_data = user_data;
100 conn_handle->proxy_changed_callback = callback;
103 static void __connection_set_internet_state_changed_callback(connection_handle_s *conn_handle,
104 void *callback, void *user_data)
106 conn_handle->internet_state_changed_user_data = user_data;
107 conn_handle->internet_state_changed_callback = callback;
110 static void __connection_set_ethernet_cable_state_changed_cb(connection_handle_s *conn_handle,
111 void *callback, void *user_data)
113 conn_handle->ethernet_cable_state_changed_callback = callback;
114 conn_handle->ethernet_cable_state_changed_user_data = user_data;
117 static void __connection_set_default_cellular_service_profile_callback(connection_handle_s *conn_handle,
118 void *callback, void *user_data)
120 conn_handle->set_default_callback = callback;
121 conn_handle->set_default_user_data = user_data;
124 static void __connection_open_profile_set_callback(connection_handle_s *conn_handle,
125 void *callback, void *user_data)
127 conn_handle->opened_callback = callback;
128 conn_handle->opened_user_data = user_data;
131 static void __connection_close_profile_set_callback(connection_handle_s *conn_handle,
132 void *callback, void *user_data)
134 conn_handle->closed_callback = callback;
135 conn_handle->closed_user_data = user_data;
138 static void __connection_reset_profile_set_callback(connection_handle_s *conn_handle,
139 void *callback, void *user_data)
141 conn_handle->reset_callback = callback;
142 conn_handle->reset_user_data = user_data;
146 /* Connection Manager ********************************************************/
147 EXPORT_API int connection_create(connection_h *connection)
151 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
155 if (connection == NULL || __connection_check_handle_validity(*connection)) {
156 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
157 CONN_UNLOCK; //LCOV_EXCL_LINE
158 return CONNECTION_ERROR_INVALID_PARAMETER;
161 *connection = g_try_malloc0(sizeof(connection_handle_s));
162 if (*connection != NULL) {
163 CONNECTION_LOG(CONNECTION_INFO, "New handle created[%p]", *connection);
165 CONN_UNLOCK; //LCOV_EXCL_LINE
166 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
169 rv = _connection_libnet_init(*connection);
170 if (rv == NET_ERR_ACCESS_DENIED) {
171 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
172 g_free(*connection); //LCOV_EXCL_LINE
173 *connection = NULL; //LCOV_EXCL_LINE
174 CONN_UNLOCK; //LCOV_EXCL_LINE
175 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
176 } else if (rv != NET_ERR_NONE) {
177 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create connection[%d]", rv); //LCOV_EXCL_LINE
178 g_free(*connection); //LCOV_EXCL_LINE
179 *connection = NULL; //LCOV_EXCL_LINE
180 CONN_UNLOCK; //LCOV_EXCL_LINE
181 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
184 conn_handle_list = g_slist_prepend(conn_handle_list, *connection);
187 return CONNECTION_ERROR_NONE;
190 EXPORT_API int connection_destroy(connection_h connection)
194 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
196 if (!(__connection_check_handle_validity(connection))) {
197 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
199 return CONNECTION_ERROR_INVALID_PARAMETER;
202 CONNECTION_LOG(CONNECTION_INFO, "Destroy handle: %p", connection);
204 __connection_set_type_changed_callback(connection, NULL, NULL);
205 __connection_set_ip_changed_callback(connection, NULL, NULL);
206 __connection_set_proxy_changed_callback(connection, NULL, NULL);
207 __connection_set_internet_state_changed_callback(connection, NULL, NULL);
208 __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
210 conn_handle_list = g_slist_remove(conn_handle_list, connection);
211 _connection_libnet_deinit(connection, (conn_handle_list == NULL));
217 return CONNECTION_ERROR_NONE;
221 EXPORT_API int connection_create_cs(int tid, connection_h *connection)
225 rv = connection_create(connection);
226 if (rv == CONNECTION_ERROR_NONE) {
228 _connection_set_cs_tid(tid, *connection);
235 EXPORT_API int connection_destroy_cs(int tid, connection_h connection)
241 if (!(__connection_check_handle_validity(connection))) {
242 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
244 return CONNECTION_ERROR_INVALID_PARAMETER;
247 CONNECTION_LOG(CONNECTION_INFO, "Destroy connection handle: %p", connection);
248 _connection_unset_cs_tid(tid, connection);
251 rv = connection_destroy(connection);
257 EXPORT_API int connection_get_type(connection_h connection, connection_type_e* type)
264 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
266 if (type == NULL || !(__connection_check_handle_validity(connection))) {
267 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
269 return CONNECTION_ERROR_INVALID_PARAMETER;
272 rv = vconf_get_int(VCONFKEY_NETWORK_STATUS, &status);
273 if (rv != VCONF_OK) {
274 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed = %d", status); //LCOV_EXCL_LINE
275 CONN_UNLOCK; //LCOV_EXCL_LINE
276 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
279 CONNECTION_LOG(CONNECTION_INFO, "Connected Network = %d", status);
281 *type = __connection_convert_net_state(status);
284 return CONNECTION_ERROR_NONE;
287 EXPORT_API int connection_get_ip_address(connection_h connection,
288 connection_address_family_e address_family, char** ip_address)
292 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
294 if (ip_address == NULL || !(__connection_check_handle_validity(connection))) {
295 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
297 return CONNECTION_ERROR_INVALID_PARAMETER;
300 switch (address_family) {
301 case CONNECTION_ADDRESS_FAMILY_IPV4:
302 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP);
304 case CONNECTION_ADDRESS_FAMILY_IPV6:
305 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP6);
308 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
310 return CONNECTION_ERROR_INVALID_PARAMETER;
313 if (*ip_address == NULL) {
314 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
315 CONN_UNLOCK; //LCOV_EXCL_LINE
316 return CONNECTION_ERROR_OPERATION_FAILED;//LCOV_EXCL_LINE
320 return CONNECTION_ERROR_NONE;
323 EXPORT_API int connection_get_proxy(connection_h connection,
324 connection_address_family_e address_family, char** proxy)
328 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
330 if (proxy == NULL || !(__connection_check_handle_validity(connection))) {
331 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
333 return CONNECTION_ERROR_INVALID_PARAMETER;
336 switch (address_family) {
337 case CONNECTION_ADDRESS_FAMILY_IPV4:
338 case CONNECTION_ADDRESS_FAMILY_IPV6:
339 *proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
342 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
344 return CONNECTION_ERROR_INVALID_PARAMETER;
347 if (*proxy == NULL) {
348 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
349 CONN_UNLOCK; //LCOV_EXCL_LINE
350 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
354 return CONNECTION_ERROR_NONE;
357 EXPORT_API int connection_get_mac_address(connection_h connection, connection_type_e type, char** mac_addr)
360 char buf[CONNECTION_MAC_INFO_LENGTH + 1];
364 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE, ETHERNET_FEATURE);
366 if (type == CONNECTION_TYPE_WIFI)
367 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
368 else if (type == CONNECTION_TYPE_ETHERNET) //LCOV_EXCL_LINE
369 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE); //LCOV_EXCL_LINE
371 if (mac_addr == NULL || !(__connection_check_handle_validity(connection))) {
372 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
374 return CONNECTION_ERROR_INVALID_PARAMETER;
378 case CONNECTION_TYPE_WIFI:
379 if (access(WIFI_MAC_INFO_FILE, F_OK) == 0)
380 fp = fopen(WIFI_MAC_INFO_FILE, "r");
383 if (fgets(buf, sizeof(buf), fp) == NULL) {
384 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", WIFI_MAC_INFO_FILE);
387 return CONNECTION_ERROR_OPERATION_FAILED;
390 CONNECTION_LOG(CONNECTION_INFO, "%s : %s", WIFI_MAC_INFO_FILE, buf);
392 *mac_addr = g_strdup(buf);
395 *mac_addr = vconf_get_str(VCONFKEY_WIFI_BSSID_ADDRESS);
397 if (*mac_addr == NULL) {
398 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get vconf from %s", VCONFKEY_WIFI_BSSID_ADDRESS); //LCOV_EXCL_LINE
399 CONN_UNLOCK; //LCOV_EXCL_LINE
400 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
403 if (strlen(*mac_addr) == 0) {
404 CONNECTION_LOG(CONNECTION_ERROR, "Mac address is invalid"
405 " from %s", VCONFKEY_WIFI_BSSID_ADDRESS); //LCOV_EXCL_LINE
406 g_free(*mac_addr); //LCOV_EXCL_LINE
407 *mac_addr = NULL; //LCOV_EXCL_LINE
408 CONN_UNLOCK; //LCOV_EXCL_LINE
409 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
414 case CONNECTION_TYPE_ETHERNET:
415 fp = fopen(ETHERNET_MAC_INFO_FILE, "r");
417 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", ETHERNET_MAC_INFO_FILE);
419 return CONNECTION_ERROR_OUT_OF_MEMORY;
422 if (fgets(buf, sizeof(buf), fp) == NULL) {
423 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", ETHERNET_MAC_INFO_FILE);
426 return CONNECTION_ERROR_OPERATION_FAILED;
429 CONNECTION_LOG(CONNECTION_INFO, "%s : %s", ETHERNET_MAC_INFO_FILE, buf);
431 *mac_addr = g_strdup(buf);
436 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
437 CONN_UNLOCK; //LCOV_EXCL_LINE
438 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
441 /* Checking Invalid MAC Address */
442 if ((strcmp(*mac_addr, "00:00:00:00:00:00") == 0) ||
443 (strcmp(*mac_addr, "ff:ff:ff:ff:ff:ff") == 0)) {
444 CONNECTION_LOG(CONNECTION_ERROR, "MAC Address(%s) is invalid", *mac_addr); //LCOV_EXCL_LINE
445 CONN_UNLOCK; //LCOV_EXCL_LINE
446 return CONNECTION_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
449 CONNECTION_LOG(CONNECTION_INFO, "MAC Address %s", *mac_addr);
452 return CONNECTION_ERROR_NONE;
456 EXPORT_API int connection_is_metered_network(connection_h connection, bool* is_metered)
460 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
462 if (is_metered == NULL || !(__connection_check_handle_validity(connection))) {
463 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
465 return CONNECTION_ERROR_INVALID_PARAMETER;
468 int rv = _connection_libnet_get_metered_state(connection, is_metered);
469 if (rv != CONNECTION_ERROR_NONE) {
470 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get metered state[%d]", rv); //LCOV_EXCL_LINE
471 CONN_UNLOCK; //LCOV_EXCL_LINE
472 return rv; //LCOV_EXCL_LINE
475 CONNECTION_LOG(CONNECTION_INFO, "metered state: %s", is_metered ? "true" : "false");
477 return CONNECTION_ERROR_NONE;
481 EXPORT_API int connection_get_cellular_state(connection_h connection, connection_cellular_state_e* state)
485 int cellular_state = 0;
486 #if defined TIZEN_DUALSIM_ENABLE
492 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
494 if (state == NULL || !(__connection_check_handle_validity(connection))) {
495 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
497 return CONNECTION_ERROR_INVALID_PARAMETER;
500 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &status);
501 if (rv != VCONF_OK) {
502 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
503 CONN_UNLOCK; //LCOV_EXCL_LINE
504 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
507 CONNECTION_LOG(CONNECTION_INFO, "Cellular: %d", status);
508 *state = __connection_convert_cellular_state(status);
510 if (*state == CONNECTION_CELLULAR_STATE_AVAILABLE) {
511 #if defined TIZEN_DUALSIM_ENABLE
512 rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
513 if (rv != VCONF_OK) {
514 CONNECTION_LOG(CONNECTION_ERROR,
515 "Failed to get default subscriber id", sim_id);
517 return CONNECTION_ERROR_OPERATION_FAILED;
521 case CONNECTION_CELLULAR_SUBSCRIBER_1:
523 rv = vconf_get_int(VCONFKEY_DNET_STATE, &cellular_state);
524 #if defined TIZEN_DUALSIM_ENABLE
527 case CONNECTION_CELLULAR_SUBSCRIBER_2:
528 rv = vconf_get_int(VCONFKEY_DNET_STATE2, &cellular_state);
532 CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
534 return CONNECTION_ERROR_OPERATION_FAILED;
537 if (rv != VCONF_OK) {
538 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
539 CONN_UNLOCK; //LCOV_EXCL_LINE
540 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
544 CONNECTION_LOG(CONNECTION_INFO, "Cellular state: %d", cellular_state);
546 if (cellular_state == VCONFKEY_DNET_NORMAL_CONNECTED ||
547 cellular_state == VCONFKEY_DNET_SECURE_CONNECTED ||
548 cellular_state == VCONFKEY_DNET_TRANSFER)
549 *state = CONNECTION_CELLULAR_STATE_CONNECTED;
552 return CONNECTION_ERROR_NONE;
555 EXPORT_API int connection_get_wifi_state(connection_h connection, connection_wifi_state_e* state)
559 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
561 if (state == NULL || !(__connection_check_handle_validity(connection))) {
562 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
564 return CONNECTION_ERROR_INVALID_PARAMETER;
567 int rv = _connection_libnet_get_wifi_state(connection, state);
568 if (rv != CONNECTION_ERROR_NONE) {
569 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get Wi-Fi state[%d]", rv); //LCOV_EXCL_LINE
570 CONN_UNLOCK; //LCOV_EXCL_LINE
571 return rv; //LCOV_EXCL_LINE
574 CONNECTION_LOG(CONNECTION_INFO, "Wi-Fi state: %d", *state);
577 return CONNECTION_ERROR_NONE;
580 EXPORT_API int connection_get_ethernet_state(connection_h connection, connection_ethernet_state_e *state)
584 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
586 if (state == NULL || !(__connection_check_handle_validity(connection))) {
587 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
589 return CONNECTION_ERROR_INVALID_PARAMETER;
592 int rv = _connection_libnet_get_ethernet_state(connection, state);
593 if (rv != CONNECTION_ERROR_NONE) {
594 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get ethernet state[%d]", rv); //LCOV_EXCL_LINE
595 CONN_UNLOCK; //LCOV_EXCL_LINE
596 return rv; //LCOV_EXCL_LINE
600 return CONNECTION_ERROR_NONE;
603 EXPORT_API int connection_get_ethernet_cable_state(connection_h connection, connection_ethernet_cable_state_e *state)
607 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
609 if (state == NULL || !(__connection_check_handle_validity(connection))) {
610 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
612 return CONNECTION_ERROR_INVALID_PARAMETER;
615 int rv = _connection_libnet_get_ethernet_cable_state(connection, state);
616 if (rv != CONNECTION_ERROR_NONE) {
617 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get ethernet cable state[%d]", rv); //LCOV_EXCL_LINE
618 CONN_UNLOCK; //LCOV_EXCL_LINE
619 return rv; //LCOV_EXCL_LINE
623 return CONNECTION_ERROR_NONE;
626 EXPORT_API int connection_set_ethernet_cable_state_chaged_cb(connection_h connection,
627 connection_ethernet_cable_state_chaged_cb callback, void *user_data)
629 DEPRECATED_LOG(__FUNCTION__, "connection_set_ethernet_cable_state_changed_cb");
633 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
635 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
636 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
638 return CONNECTION_ERROR_INVALID_PARAMETER;
641 DEPRECATED_LOG("connection_ethernet_cable_state_chaged_cb",
642 "connection_ethernet_cable_state_changed_cb");
644 __connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data);
647 return CONNECTION_ERROR_NONE;
650 EXPORT_API int connection_unset_ethernet_cable_state_chaged_cb(connection_h connection)
652 DEPRECATED_LOG(__FUNCTION__, "connection_unset_ethernet_cable_state_changed_cb");
656 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
658 if (!(__connection_check_handle_validity(connection))) {
659 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
661 return CONNECTION_ERROR_INVALID_PARAMETER;
664 __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
667 return CONNECTION_ERROR_NONE;
670 EXPORT_API int connection_set_ethernet_cable_state_changed_cb(connection_h connection,
671 connection_ethernet_cable_state_changed_cb callback, void *user_data)
675 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
677 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
678 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
680 return CONNECTION_ERROR_INVALID_PARAMETER;
683 __connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data);
686 return CONNECTION_ERROR_NONE;
689 EXPORT_API int connection_unset_ethernet_cable_state_changed_cb(connection_h connection)
693 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
695 if (!(__connection_check_handle_validity(connection))) {
696 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
698 return CONNECTION_ERROR_INVALID_PARAMETER;
701 __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
704 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
722 CONN_UNLOCK; //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_set_internet_state_changed_cb(connection_h connection,
842 connection_internet_state_changed_cb callback, void *user_data)
846 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
848 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
849 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
851 return CONNECTION_ERROR_INVALID_PARAMETER;
854 __connection_set_internet_state_changed_callback(connection, callback, user_data);
857 return CONNECTION_ERROR_NONE;
860 EXPORT_API int connection_unset_internet_state_changed_cb(connection_h connection)
864 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
866 if (!(__connection_check_handle_validity(connection))) {
867 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
869 return CONNECTION_ERROR_INVALID_PARAMETER;
872 __connection_set_internet_state_changed_callback(connection, NULL, NULL);
875 return CONNECTION_ERROR_NONE;
878 EXPORT_API int connection_add_profile(connection_h connection, connection_profile_h profile)
881 connection_handle_s *conn_handle = (connection_handle_s *)connection;
882 net_profile_info_t *profile_info = (net_profile_info_t *)profile;
886 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
888 if (!(__connection_check_handle_validity(connection)) ||
889 !(_connection_libnet_check_profile_validity(profile))) {
890 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
892 return CONNECTION_ERROR_INVALID_PARAMETER;
895 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
896 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
897 CONN_UNLOCK; //LCOV_EXCL_LINE
898 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
901 if (profile_info->ProfileInfo.Pdp.PSModemPath[0] != '/' ||
902 strlen(profile_info->ProfileInfo.Pdp.PSModemPath) < 2) {
903 CONNECTION_LOG(CONNECTION_ERROR, "Modem object path is NULL"); //LCOV_EXCL_LINE
904 CONN_UNLOCK; //LCOV_EXCL_LINE
905 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
908 rv = net_add_profile(conn_handle->network_info_handle,
909 profile_info->ProfileInfo.Pdp.ServiceType, profile_info);
910 if (rv == NET_ERR_ACCESS_DENIED) {
911 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
912 CONN_UNLOCK; //LCOV_EXCL_LINE
913 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
914 } else if (rv != NET_ERR_NONE) {
915 CONNECTION_LOG(CONNECTION_ERROR, "Failed to add profile[%d]", rv); //LCOV_EXCL_LINE
916 CONN_UNLOCK; //LCOV_EXCL_LINE
917 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
921 return CONNECTION_ERROR_NONE;
924 EXPORT_API int connection_remove_profile(connection_h connection, connection_profile_h profile)
927 connection_handle_s *conn_handle = (connection_handle_s *)connection;
928 net_profile_info_t *profile_info = (net_profile_info_t *)profile;
932 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
934 if (!(__connection_check_handle_validity(connection)) ||
935 !(_connection_libnet_check_profile_validity(profile))) {
936 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
938 return CONNECTION_ERROR_INVALID_PARAMETER;
941 if (profile_info->profile_type != NET_DEVICE_CELLULAR &&
942 profile_info->profile_type != NET_DEVICE_MESH &&
943 profile_info->profile_type != NET_DEVICE_WIFI) {
944 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
945 CONN_UNLOCK; //LCOV_EXCL_LINE
946 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
949 rv = net_delete_profile(conn_handle->network_info_handle, profile_info->ProfileName);
950 if (rv == NET_ERR_ACCESS_DENIED) {
951 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
952 CONN_UNLOCK; //LCOV_EXCL_LINE
953 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
954 } else if (rv != NET_ERR_NONE) {
955 CONNECTION_LOG(CONNECTION_ERROR, "Failed to delete profile[%d]", rv); //LCOV_EXCL_LINE
956 CONN_UNLOCK; //LCOV_EXCL_LINE
957 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
961 return CONNECTION_ERROR_NONE;
964 EXPORT_API int connection_update_profile(connection_h connection, connection_profile_h profile)
967 connection_handle_s *conn_handle = (connection_handle_s *)connection;
968 net_profile_info_t *profile_info = (net_profile_info_t *)profile;
972 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
974 if (!(__connection_check_handle_validity(connection)) ||
975 !(_connection_libnet_check_profile_validity(profile))) {
976 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
978 return CONNECTION_ERROR_INVALID_PARAMETER;
981 rv = net_modify_profile(conn_handle->network_info_handle,
982 profile_info->ProfileName, (net_profile_info_t*)profile);
983 if (rv == NET_ERR_ACCESS_DENIED) {
984 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
985 CONN_UNLOCK; //LCOV_EXCL_LINE
986 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
987 } else if (rv != NET_ERR_NONE) {
988 CONNECTION_LOG(CONNECTION_ERROR, "Failed to modify profile[%d]", rv); //LCOV_EXCL_LINE
989 CONN_UNLOCK; //LCOV_EXCL_LINE
990 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
994 return CONNECTION_ERROR_NONE;
997 EXPORT_API int connection_get_profile_iterator(connection_h connection,
998 connection_iterator_type_e type, connection_profile_iterator_h* profile_iterator)
1002 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1004 if (!(__connection_check_handle_validity(connection)) ||
1005 (type != CONNECTION_ITERATOR_TYPE_REGISTERED &&
1006 type != CONNECTION_ITERATOR_TYPE_CONNECTED &&
1007 type != CONNECTION_ITERATOR_TYPE_DEFAULT)) {
1008 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1010 return CONNECTION_ERROR_INVALID_PARAMETER;
1013 int rv = _connection_libnet_get_profile_iterator(connection, type, profile_iterator);
1014 if (rv != CONNECTION_ERROR_NONE) {
1015 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get profile iterator [%d]", rv); //LCOV_EXCL_LINE
1016 CONN_UNLOCK; //LCOV_EXCL_LINE
1017 return rv; //LCOV_EXCL_LINE
1021 return CONNECTION_ERROR_NONE;
1024 EXPORT_API int connection_profile_iterator_next(connection_profile_iterator_h profile_iterator,
1025 connection_profile_h* profile)
1029 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1031 int rv = _connection_libnet_get_iterator_next(profile_iterator, profile);
1037 EXPORT_API bool connection_profile_iterator_has_next(connection_profile_iterator_h profile_iterator)
1041 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1043 int rv = _connection_libnet_iterator_has_next(profile_iterator);
1049 EXPORT_API int connection_destroy_profile_iterator(connection_profile_iterator_h profile_iterator)
1053 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1055 int rv = _connection_libnet_destroy_iterator(profile_iterator);
1061 EXPORT_API int connection_get_current_profile(connection_h connection, connection_profile_h* profile)
1065 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1067 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1068 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1070 return CONNECTION_ERROR_INVALID_PARAMETER;
1073 int rv = _connection_libnet_get_current_profile(connection, profile);
1074 if (rv != CONNECTION_ERROR_NONE) {
1075 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get current profile [%d]", rv); //LCOV_EXCL_LINE
1076 CONN_UNLOCK; //LCOV_EXCL_LINE
1077 return rv; //LCOV_EXCL_LINE
1081 return CONNECTION_ERROR_NONE;
1084 EXPORT_API int connection_get_default_cellular_service_profile(
1085 connection_h connection, connection_cellular_service_type_e type,
1086 connection_profile_h *profile)
1090 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1092 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1093 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1095 return CONNECTION_ERROR_INVALID_PARAMETER;
1098 int rv = _connection_libnet_get_cellular_service_profile(connection, type, profile);
1099 if (rv != CONNECTION_ERROR_NONE) {
1100 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get default cellular service profile [%d]", rv); //LCOV_EXCL_LINE
1101 CONN_UNLOCK; //LCOV_EXCL_LINE
1102 return rv; //LCOV_EXCL_LINE
1106 return CONNECTION_ERROR_NONE;
1109 EXPORT_API int connection_set_default_cellular_service_profile(connection_h connection,
1110 connection_cellular_service_type_e type, connection_profile_h profile)
1114 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1116 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1117 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1119 return CONNECTION_ERROR_INVALID_PARAMETER;
1122 int rv = _connection_libnet_set_cellular_service_profile_sync(connection, type, profile);
1123 if (rv != CONNECTION_ERROR_NONE) {
1124 CONNECTION_LOG(CONNECTION_ERROR, "Fail to set default cellular service profile [%d]", rv); //LCOV_EXCL_LINE
1125 CONN_UNLOCK; //LCOV_EXCL_LINE
1126 return rv; //LCOV_EXCL_LINE
1130 return CONNECTION_ERROR_NONE;
1133 EXPORT_API int connection_set_default_cellular_service_profile_async(connection_h connection,
1134 connection_cellular_service_type_e type, connection_profile_h profile,
1135 connection_set_default_cb callback, void* user_data)
1139 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1143 if (!(__connection_check_handle_validity(connection)) ||
1144 profile == NULL || callback == NULL) {
1145 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1147 return CONNECTION_ERROR_INVALID_PARAMETER;
1150 rv = _connection_libnet_set_cellular_service_profile_async(connection, type, profile);
1151 if (rv == NET_ERR_ACCESS_DENIED) {
1152 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1153 CONN_UNLOCK; //LCOV_EXCL_LINE
1154 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1155 } else if (rv != NET_ERR_NONE) {
1156 CONNECTION_LOG(CONNECTION_ERROR, "Failed to set default cellular service profile[%d]", rv); //LCOV_EXCL_LINE
1157 CONN_UNLOCK; //LCOV_EXCL_LINE
1158 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1161 __connection_set_default_cellular_service_profile_callback(connection, callback, user_data);
1164 return CONNECTION_ERROR_NONE;
1167 EXPORT_API int connection_open_profile(connection_h connection, connection_profile_h profile,
1168 connection_opened_cb callback, void* user_data)
1172 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1176 if (!(__connection_check_handle_validity(connection)) ||
1177 profile == NULL || callback == NULL) {
1178 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1180 return CONNECTION_ERROR_INVALID_PARAMETER;
1183 rv = _connection_libnet_open_profile(connection, profile);
1184 if (rv == NET_ERR_ACCESS_DENIED) {
1185 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1186 CONN_UNLOCK; //LCOV_EXCL_LINE
1187 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1188 } else if (rv != NET_ERR_NONE) {
1189 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open profile[%d]", rv); //LCOV_EXCL_LINE
1190 CONN_UNLOCK; //LCOV_EXCL_LINE
1191 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1194 __connection_open_profile_set_callback(connection, callback, user_data);
1197 return CONNECTION_ERROR_NONE;
1200 EXPORT_API int connection_close_profile(connection_h connection, connection_profile_h profile,
1201 connection_closed_cb callback, void* user_data)
1205 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1209 if (!(__connection_check_handle_validity(connection)) ||
1210 profile == NULL || callback == NULL) {
1211 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1213 return CONNECTION_ERROR_INVALID_PARAMETER;
1216 rv = _connection_libnet_close_profile(connection, profile);
1217 if (rv == NET_ERR_ACCESS_DENIED) {
1218 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1219 CONN_UNLOCK; //LCOV_EXCL_LINE
1220 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1221 } else if (rv != NET_ERR_NONE) {
1222 CONNECTION_LOG(CONNECTION_ERROR, "Failed to close profile[%d]", rv); //LCOV_EXCL_LINE
1223 CONN_UNLOCK; //LCOV_EXCL_LINE
1224 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1227 __connection_close_profile_set_callback(connection, callback, user_data);
1230 return CONNECTION_ERROR_NONE;
1233 EXPORT_API int connection_reset_profile(connection_h connection,
1234 connection_reset_option_e type, int id, connection_reset_cb callback, void *user_data)
1238 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1242 if (!(__connection_check_handle_validity(connection))) {
1243 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
1245 return CONNECTION_ERROR_INVALID_PARAMETER;
1248 if (id < 0 || id > 1) {
1249 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed"); //LCOV_EXCL_LINE
1250 CONN_UNLOCK; //LCOV_EXCL_LINE
1251 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1254 rv = _connection_libnet_reset_profile(connection, type, id);
1255 if (rv == NET_ERR_ACCESS_DENIED) {
1256 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1257 CONN_UNLOCK; //LCOV_EXCL_LINE
1258 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1259 } else if (rv != NET_ERR_NONE) {
1260 CONNECTION_LOG(CONNECTION_ERROR, "Failed to reset profile[%d]", rv); //LCOV_EXCL_LINE
1261 CONN_UNLOCK; //LCOV_EXCL_LINE
1262 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1265 __connection_reset_profile_set_callback(connection, callback, user_data);
1268 return CONNECTION_ERROR_NONE;
1271 EXPORT_API int connection_add_route(connection_h connection, const char* interface_name, const char* host_address)
1275 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1277 if (!(__connection_check_handle_validity(connection)) ||
1278 interface_name == NULL || host_address == NULL) {
1279 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1281 return CONNECTION_ERROR_INVALID_PARAMETER;
1284 int rv = _connection_libnet_add_route(connection, interface_name, host_address);
1285 if (rv != CONNECTION_ERROR_NONE) {
1286 CONNECTION_LOG(CONNECTION_ERROR, "Fail to add route [%d]", rv); //LCOV_EXCL_LINE
1287 CONN_UNLOCK; //LCOV_EXCL_LINE
1288 return rv; //LCOV_EXCL_LINE
1292 return CONNECTION_ERROR_NONE;
1295 EXPORT_API int connection_remove_route(connection_h connection, const char* interface_name, const char* host_address)
1299 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1301 if (!(__connection_check_handle_validity(connection)) ||
1302 interface_name == NULL || host_address == NULL) {
1303 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1305 return CONNECTION_ERROR_INVALID_PARAMETER;
1308 int rv = _connection_libnet_remove_route(connection, interface_name, host_address);
1309 if (rv != CONNECTION_ERROR_NONE) {
1310 CONNECTION_LOG(CONNECTION_ERROR, "Fail to remove route [%d]", rv); //LCOV_EXCL_LINE
1311 CONN_UNLOCK; //LCOV_EXCL_LINE
1312 return rv; //LCOV_EXCL_LINE
1316 return CONNECTION_ERROR_NONE;
1319 EXPORT_API int connection_add_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1323 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1325 if (!(__connection_check_handle_validity(connection)) ||
1326 interface_name == NULL || host_address == NULL) {
1327 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1329 return CONNECTION_ERROR_INVALID_PARAMETER;
1332 int rv = _connection_libnet_add_route_ipv6(connection, interface_name, host_address, gateway);
1333 if (rv != CONNECTION_ERROR_NONE) {
1334 CONNECTION_LOG(CONNECTION_ERROR, "Fail to add route ipv6 [%d]", rv); //LCOV_EXCL_LINE
1335 CONN_UNLOCK; //LCOV_EXCL_LINE
1336 return rv; //LCOV_EXCL_LINE
1340 return CONNECTION_ERROR_NONE;
1343 EXPORT_API int connection_remove_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1347 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1349 if (!(__connection_check_handle_validity(connection)) ||
1350 interface_name == NULL || host_address == NULL) {
1351 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1353 return CONNECTION_ERROR_INVALID_PARAMETER;
1356 int rv = _connection_libnet_remove_route_ipv6(connection, interface_name, host_address, gateway);
1357 if (rv != CONNECTION_ERROR_NONE) {
1358 CONNECTION_LOG(CONNECTION_ERROR, "Fail to remove route ipv6 [%d]", rv); //LCOV_EXCL_LINE
1359 CONN_UNLOCK; //LCOV_EXCL_LINE
1360 return rv; //LCOV_EXCL_LINE
1364 return CONNECTION_ERROR_NONE;
1367 EXPORT_API int connection_add_route_entry(connection_h connection,
1368 connection_address_family_e address_family, const char *interface_name,
1369 const char *host_address, const char *gateway)
1373 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1375 if (!(__connection_check_handle_validity(connection)) ||
1376 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1377 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1378 interface_name == NULL || host_address == NULL) {
1379 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1381 return CONNECTION_ERROR_INVALID_PARAMETER;
1384 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1385 int rv = _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
1386 interface_name, host_address, gateway);
1390 int rv = _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
1391 interface_name, host_address, gateway);
1397 EXPORT_API int connection_remove_route_entry(connection_h connection,
1398 connection_address_family_e address_family, const char *interface_name,
1399 const char *host_address, const char *gateway)
1403 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1405 if (!(__connection_check_handle_validity(connection)) ||
1406 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1407 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1408 interface_name == NULL || host_address == NULL) {
1409 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1411 return CONNECTION_ERROR_INVALID_PARAMETER;
1414 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1415 int rv = _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
1416 interface_name, host_address, gateway);
1420 int rv = _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
1421 interface_name, host_address, gateway);
1427 static int __get_cellular_statistic(connection_statistics_type_e statistics_type, long long *llsize)
1429 int rv = VCONF_OK, rv1 = VCONF_OK;
1430 int last_size = 0, size = 0;
1431 #if defined TIZEN_DUALSIM_ENABLE
1435 if (llsize == NULL) {
1436 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1437 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1440 switch (statistics_type) {
1441 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1442 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1443 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1444 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1447 return CONNECTION_ERROR_INVALID_PARAMETER;
1450 #if defined TIZEN_DUALSIM_ENABLE
1451 rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
1452 if (rv != VCONF_OK) {
1453 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get default subscriber id");
1455 return CONNECTION_ERROR_OPERATION_FAILED;
1461 switch (statistics_type) {
1462 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1463 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1465 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1466 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1468 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1469 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1470 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT, &size);
1472 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1473 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1474 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV, &size);
1477 #if defined TIZEN_DUALSIM_ENABLE
1480 switch (statistics_type) {
1481 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1482 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1484 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1485 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1487 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1488 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1489 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT2, &size);
1491 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1492 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1493 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV2, &size);
1499 CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
1500 return CONNECTION_ERROR_OPERATION_FAILED;
1504 if (rv != VCONF_OK || rv1 != VCONF_OK) {
1505 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular statistics"); //LCOV_EXCL_LINE
1506 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1509 *llsize = (long long)(last_size * 1000) + (long long)(size * 1000);
1510 CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", *llsize);
1512 return CONNECTION_ERROR_NONE;
1515 static int __get_statistic(connection_handle_s *conn_handle, connection_type_e connection_type,
1516 connection_statistics_type_e statistics_type, long long *llsize)
1519 unsigned long long ull_size;
1521 if (llsize == NULL) {
1522 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1523 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1526 rv = _connection_libnet_check_get_privilege();
1527 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1529 else if (rv != CONNECTION_ERROR_NONE) {
1530 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get statistics"); //LCOV_EXCL_LINE
1531 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1534 if (connection_type == CONNECTION_TYPE_CELLULAR)
1535 return __get_cellular_statistic(statistics_type, llsize);
1536 else if (connection_type == CONNECTION_TYPE_WIFI) {
1537 switch (statistics_type) {
1538 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1539 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1541 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1542 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1544 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1545 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1547 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1548 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1551 return CONNECTION_ERROR_INVALID_PARAMETER;
1554 CONNECTION_LOG(CONNECTION_INFO, "connection type[%d] statistics type[%d]",
1555 connection_type, statistics_type);
1557 rv = _connection_libnet_get_statistics(conn_handle, stat_type, &ull_size);
1558 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1560 else if (rv != CONNECTION_ERROR_NONE) {
1561 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get Wi-Fi statistics"); //LCOV_EXCL_LINE
1562 *llsize = 0; //LCOV_EXCL_LINE
1563 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1566 CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", ull_size);
1567 *llsize = (long long)ull_size;
1569 return CONNECTION_ERROR_INVALID_PARAMETER;
1571 return CONNECTION_ERROR_NONE;
1574 static int __reset_statistic(connection_handle_s *conn_handle,
1575 connection_type_e connection_type, connection_statistics_type_e statistics_type)
1581 if (connection_type == CONNECTION_TYPE_CELLULAR)
1582 conn_type = NET_DEVICE_CELLULAR;
1583 else if (connection_type == CONNECTION_TYPE_WIFI)
1584 conn_type = NET_DEVICE_WIFI;
1586 return CONNECTION_ERROR_INVALID_PARAMETER;
1588 switch (statistics_type) {
1589 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1590 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1592 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1593 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1595 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1596 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1598 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1599 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1602 return CONNECTION_ERROR_INVALID_PARAMETER;
1605 rv = _connection_libnet_set_statistics(conn_handle, conn_type, stat_type);
1606 if (rv != CONNECTION_ERROR_NONE)
1609 CONNECTION_LOG(CONNECTION_INFO, "connection_reset_statistics success");
1611 return CONNECTION_ERROR_NONE;
1614 EXPORT_API int connection_get_statistics(connection_h connection,
1615 connection_type_e connection_type,
1616 connection_statistics_type_e statistics_type, long long* size)
1620 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1622 if (connection_type == CONNECTION_TYPE_CELLULAR)
1623 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1624 else if (connection_type == CONNECTION_TYPE_WIFI)
1625 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1627 if (!(__connection_check_handle_validity(connection)) || size == NULL) {
1628 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1630 return CONNECTION_ERROR_INVALID_PARAMETER;
1633 int rv = __get_statistic(connection, connection_type, statistics_type, size);
1634 if (rv != CONNECTION_ERROR_NONE) {
1635 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get statistics [%d]", rv); //LCOV_EXCL_LINE
1637 return rv; //LCOV_EXCL_LINE
1641 return CONNECTION_ERROR_NONE;
1644 EXPORT_API int connection_reset_statistics(connection_h connection,
1645 connection_type_e connection_type,
1646 connection_statistics_type_e statistics_type)
1650 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1652 if (connection_type == CONNECTION_TYPE_CELLULAR)
1653 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1654 else if (connection_type == CONNECTION_TYPE_WIFI)
1655 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1657 if (!__connection_check_handle_validity(connection)) {
1658 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1660 return CONNECTION_ERROR_INVALID_PARAMETER;
1663 int rv = __reset_statistic(connection, connection_type, statistics_type);
1664 if (rv != CONNECTION_ERROR_NONE) {
1665 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get statistics [%d]", rv); //LCOV_EXCL_LINE
1667 return rv; //LCOV_EXCL_LINE
1671 return CONNECTION_ERROR_NONE;
1674 EXPORT_API int connection_foreach_ipv6_address(connection_h connection,
1675 connection_type_e connection_type, connection_ipv6_address_cb callback,
1680 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1681 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1683 GSList *ipv6_address_list = NULL;
1685 if (!(__connection_check_handle_validity(connection))) {
1686 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1688 return CONNECTION_ERROR_INVALID_PARAMETER;
1691 int rv = CONNECTION_ERROR_NONE;
1693 switch (connection_type) {
1694 case CONNECTION_TYPE_WIFI:
1695 rv = net_foreach_ipv6_address(NET_DEVICE_WIFI,
1696 &ipv6_address_list);
1698 case CONNECTION_TYPE_CELLULAR:
1699 rv = net_foreach_ipv6_address(NET_DEVICE_CELLULAR,
1700 &ipv6_address_list);
1702 case CONNECTION_TYPE_ETHERNET:
1703 rv = net_foreach_ipv6_address(NET_DEVICE_ETHERNET,
1704 &ipv6_address_list);
1706 case CONNECTION_TYPE_BT:
1707 rv = net_foreach_ipv6_address(NET_DEVICE_BLUETOOTH,
1708 &ipv6_address_list);
1711 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1713 return CONNECTION_ERROR_INVALID_PARAMETER;
1716 if (rv != NET_ERR_NONE) {
1717 CONNECTION_LOG(CONNECTION_ERROR, "net_get_multiple_id_address" //LCOV_EXCL_LINE
1718 " Failed = %d\n", rv);
1719 CONN_UNLOCK; //LCOV_EXCL_LINE
1720 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1724 for (list = ipv6_address_list; list; list = list->next) {
1725 rv = callback((char *)list->data, user_data);
1730 g_slist_free_full(ipv6_address_list, g_free);
1731 ipv6_address_list = NULL;
1734 return CONNECTION_ERROR_NONE;
1737 EXPORT_API int connection_profile_start_tcpdump(connection_h connection)
1743 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1745 if (!(__connection_check_handle_validity(connection))) {
1746 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1748 return CONNECTION_ERROR_INVALID_PARAMETER;
1751 ret = _connection_libnet_start_tcpdump(connection);
1752 if (ret != CONNECTION_ERROR_NONE) {
1753 CONNECTION_LOG(CONNECTION_ERROR, "Failed to start tcpdump (%d)", ret); //LCOV_EXCL_LINE
1754 CONN_UNLOCK; //LCOV_EXCL_LINE
1755 return ret; //LCOV_EXCL_LINE
1759 return CONNECTION_ERROR_NONE;
1762 EXPORT_API int connection_profile_stop_tcpdump(connection_h connection)
1768 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1770 if (!(__connection_check_handle_validity(connection))) {
1771 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1773 return CONNECTION_ERROR_INVALID_PARAMETER;
1776 ret = _connection_libnet_stop_tcpdump(connection);
1777 if (ret != CONNECTION_ERROR_NONE) {
1778 CONNECTION_LOG(CONNECTION_ERROR, "Failed to stop tcpdump (%d)", ret); //LCOV_EXCL_LINE
1779 CONN_UNLOCK; //LCOV_EXCL_LINE
1780 return ret; //LCOV_EXCL_LINE
1784 return CONNECTION_ERROR_NONE;
1787 EXPORT_API int connection_profile_get_tcpdump_state(connection_h connection, gboolean *tcpdump_state)
1793 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1795 if (!(__connection_check_handle_validity(connection)) || !tcpdump_state) {
1796 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1798 return CONNECTION_ERROR_INVALID_PARAMETER;
1801 ret = _connection_libnet_get_tcpdump_state(connection, tcpdump_state);
1802 if (ret != CONNECTION_ERROR_NONE) {
1803 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get the tcpdump state (%d)", ret); //LCOV_EXCL_LINE
1804 CONN_UNLOCK; //LCOV_EXCL_LINE
1805 return ret; //LCOV_EXCL_LINE
1809 return CONNECTION_ERROR_NONE;
1812 EXPORT_API int connection_profile_save_ethernet_eap_config(connection_h connection,
1813 connection_profile_h profile)
1817 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1821 if (!__connection_check_handle_validity(connection) ||
1822 !_connection_libnet_check_profile_validity(profile)) {
1823 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1825 return CONNECTION_ERROR_INVALID_PARAMETER;
1828 rv = _connection_libnet_profile_save_ethernet_eap_config(connection, profile);
1829 if (rv != CONNECTION_ERROR_NONE) {
1830 CONNECTION_LOG(CONNECTION_ERROR, "Failed to save ethernet eap config."); //LCOV_EXCL_LINE
1831 CONN_UNLOCK; //LCOV_EXCL_LINE
1832 return rv; //LCOV_EXCL_LINE
1836 return CONNECTION_ERROR_NONE;