2 * Copyright (c) 2011-2013 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
21 #include <vconf/vconf.h>
22 #include <system_info.h>
24 #include "net_connection_private.h"
26 static GSList *conn_handle_list = NULL;
27 static int tv_profile = -1; // Unknown
30 static int __connection_convert_net_state(int status)
33 case VCONFKEY_NETWORK_CELLULAR:
34 return CONNECTION_TYPE_CELLULAR;
35 case VCONFKEY_NETWORK_WIFI:
36 return CONNECTION_TYPE_WIFI;
37 case VCONFKEY_NETWORK_ETHERNET:
38 return CONNECTION_TYPE_ETHERNET;
39 case VCONFKEY_NETWORK_BLUETOOTH:
40 return CONNECTION_TYPE_BT;
41 case VCONFKEY_NETWORK_DEFAULT_PROXY:
42 return CONNECTION_TYPE_NET_PROXY;
44 return CONNECTION_TYPE_DISCONNECTED;
48 static int __connection_convert_cellular_state(int status)
51 case VCONFKEY_NETWORK_CELLULAR_ON:
52 return CONNECTION_CELLULAR_STATE_AVAILABLE;
53 case VCONFKEY_NETWORK_CELLULAR_3G_OPTION_OFF:
54 return CONNECTION_CELLULAR_STATE_CALL_ONLY_AVAILABLE;
55 case VCONFKEY_NETWORK_CELLULAR_ROAMING_OFF:
56 return CONNECTION_CELLULAR_STATE_ROAMING_OFF;
57 case VCONFKEY_NETWORK_CELLULAR_FLIGHT_MODE:
58 return CONNECTION_CELLULAR_STATE_FLIGHT_MODE;
60 return CONNECTION_CELLULAR_STATE_OUT_OF_SERVICE;
64 static bool __connection_check_handle_validity(connection_h connection)
68 if (connection == NULL)
71 if (g_slist_find(conn_handle_list, connection) != NULL)
77 bool _connection_check_handle_validity(connection_h connection)
79 return __connection_check_handle_validity(connection);
82 static void __connection_set_type_changed_callback(connection_handle_s *conn_handle,
83 void *callback, void *user_data)
85 conn_handle->type_changed_user_data = user_data;
86 conn_handle->type_changed_callback = callback;
89 static void __connection_set_ip_changed_callback(connection_handle_s *conn_handle,
90 void *callback, void *user_data)
92 conn_handle->ip_changed_user_data = user_data;
93 conn_handle->ip_changed_callback = callback;
96 static void __connection_set_proxy_changed_callback(connection_handle_s *conn_handle,
97 void *callback, void *user_data)
99 conn_handle->proxy_changed_user_data = user_data;
100 conn_handle->proxy_changed_callback = callback;
103 static void __connection_set_internet_state_changed_callback(connection_handle_s *conn_handle,
104 void *callback, void *user_data)
106 conn_handle->internet_state_changed_user_data = user_data;
107 conn_handle->internet_state_changed_callback = callback;
110 static void __connection_set_ethernet_cable_state_changed_cb(connection_handle_s *conn_handle,
111 void *callback, void *user_data)
113 conn_handle->ethernet_cable_state_changed_callback = callback;
114 conn_handle->ethernet_cable_state_changed_user_data = user_data;
117 static void __connection_set_default_cellular_service_profile_callback(connection_handle_s *conn_handle,
118 void *callback, void *user_data)
120 conn_handle->set_default_callback = callback;
121 conn_handle->set_default_user_data = user_data;
124 static void __connection_open_profile_set_callback(connection_handle_s *conn_handle,
125 void *callback, void *user_data)
127 conn_handle->opened_callback = callback;
128 conn_handle->opened_user_data = user_data;
131 static void __connection_close_profile_set_callback(connection_handle_s *conn_handle,
132 void *callback, void *user_data)
134 conn_handle->closed_callback = callback;
135 conn_handle->closed_user_data = user_data;
138 static void __connection_reset_profile_set_callback(connection_handle_s *conn_handle,
139 void *callback, void *user_data)
141 conn_handle->reset_callback = callback;
142 conn_handle->reset_user_data = user_data;
146 /* Connection Manager ********************************************************/
147 EXPORT_API int connection_create(connection_h *connection)
151 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
155 if (connection == NULL || __connection_check_handle_validity(*connection)) {
156 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
157 CONN_UNLOCK; //LCOV_EXCL_LINE
158 return CONNECTION_ERROR_INVALID_PARAMETER;
161 *connection = g_try_malloc0(sizeof(connection_handle_s));
162 if (*connection != NULL) {
163 CONNECTION_LOG(CONNECTION_INFO, "New handle created[%p]", *connection);
165 CONN_UNLOCK; //LCOV_EXCL_LINE
166 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
169 rv = _connection_libnet_init(*connection);
170 if (rv == NET_ERR_ACCESS_DENIED) {
171 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
172 CONN_UNLOCK; //LCOV_EXCL_LINE
173 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
174 } else if (rv != NET_ERR_NONE) {
175 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create connection[%d]", rv); //LCOV_EXCL_LINE
176 CONN_UNLOCK; //LCOV_EXCL_LINE
177 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
180 conn_handle_list = g_slist_prepend(conn_handle_list, *connection);
183 return CONNECTION_ERROR_NONE;
186 EXPORT_API int connection_destroy(connection_h connection)
190 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
192 if (!(__connection_check_handle_validity(connection))) {
193 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
195 return CONNECTION_ERROR_INVALID_PARAMETER;
198 CONNECTION_LOG(CONNECTION_INFO, "Destroy handle: %p", connection);
200 __connection_set_type_changed_callback(connection, NULL, NULL);
201 __connection_set_ip_changed_callback(connection, NULL, NULL);
202 __connection_set_proxy_changed_callback(connection, NULL, NULL);
203 __connection_set_internet_state_changed_callback(connection, NULL, NULL);
204 __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
206 conn_handle_list = g_slist_remove(conn_handle_list, connection);
207 _connection_libnet_deinit(connection, (conn_handle_list == NULL));
213 return CONNECTION_ERROR_NONE;
217 EXPORT_API int connection_create_cs(int tid, connection_h *connection)
221 rv = connection_create(connection);
222 if (rv == CONNECTION_ERROR_NONE) {
224 _connection_set_cs_tid(tid, *connection);
231 EXPORT_API int connection_destroy_cs(int tid, connection_h connection)
236 _connection_unset_cs_tid(tid, connection);
239 rv = connection_destroy(connection);
245 EXPORT_API int connection_get_type(connection_h connection, connection_type_e* type)
252 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
254 if (type == NULL || !(__connection_check_handle_validity(connection))) {
255 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
257 return CONNECTION_ERROR_INVALID_PARAMETER;
260 rv = vconf_get_int(VCONFKEY_NETWORK_STATUS, &status);
261 if (rv != VCONF_OK) {
262 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed = %d", status); //LCOV_EXCL_LINE
263 CONN_UNLOCK; //LCOV_EXCL_LINE
264 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
267 CONNECTION_LOG(CONNECTION_INFO, "Connected Network = %d", status);
269 *type = __connection_convert_net_state(status);
272 return CONNECTION_ERROR_NONE;
275 EXPORT_API int connection_get_ip_address(connection_h connection,
276 connection_address_family_e address_family, char** ip_address)
280 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
282 if (ip_address == NULL || !(__connection_check_handle_validity(connection))) {
283 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
285 return CONNECTION_ERROR_INVALID_PARAMETER;
288 switch (address_family) {
289 case CONNECTION_ADDRESS_FAMILY_IPV4:
290 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP);
292 case CONNECTION_ADDRESS_FAMILY_IPV6:
293 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP6);
296 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
298 return CONNECTION_ERROR_INVALID_PARAMETER;
301 if (*ip_address == NULL) {
302 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
303 CONN_UNLOCK; //LCOV_EXCL_LINE
304 return CONNECTION_ERROR_OPERATION_FAILED;//LCOV_EXCL_LINE
308 return CONNECTION_ERROR_NONE;
311 EXPORT_API int connection_get_proxy(connection_h connection,
312 connection_address_family_e address_family, char** proxy)
316 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
318 if (proxy == NULL || !(__connection_check_handle_validity(connection))) {
319 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
321 return CONNECTION_ERROR_INVALID_PARAMETER;
324 switch (address_family) {
325 case CONNECTION_ADDRESS_FAMILY_IPV4:
326 case CONNECTION_ADDRESS_FAMILY_IPV6:
327 *proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
330 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
332 return CONNECTION_ERROR_INVALID_PARAMETER;
335 if (*proxy == NULL) {
336 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
337 CONN_UNLOCK; //LCOV_EXCL_LINE
338 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
342 return CONNECTION_ERROR_NONE;
345 EXPORT_API int connection_get_mac_address(connection_h connection, connection_type_e type, char** mac_addr)
348 char buf[CONNECTION_MAC_INFO_LENGTH + 1];
352 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE, ETHERNET_FEATURE);
354 if (type == CONNECTION_TYPE_WIFI)
355 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
356 else if (type == CONNECTION_TYPE_ETHERNET) //LCOV_EXCL_LINE
357 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE); //LCOV_EXCL_LINE
359 if (mac_addr == NULL || !(__connection_check_handle_validity(connection))) {
360 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
362 return CONNECTION_ERROR_INVALID_PARAMETER;
366 case CONNECTION_TYPE_WIFI:
367 if (__builtin_expect(tv_profile == -1, 0)) {
369 system_info_get_platform_string("http://tizen.org/feature/profile", &profileName);
370 if (*profileName == 't' || *profileName == 'T')
371 tv_profile = 1; //LCOV_EXCL_LINE
376 if (tv_profile == 1) {
378 fp = fopen(WIFI_MAC_INFO_FILE, "r");
380 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", WIFI_MAC_INFO_FILE);
382 return CONNECTION_ERROR_OUT_OF_MEMORY;
385 if (fgets(buf, sizeof(buf), fp) == NULL) {
386 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", WIFI_MAC_INFO_FILE);
389 return CONNECTION_ERROR_OPERATION_FAILED;
392 CONNECTION_LOG(CONNECTION_INFO, "%s : %s", WIFI_MAC_INFO_FILE, buf);
394 *mac_addr = (char *)malloc(CONNECTION_MAC_INFO_LENGTH + 1);
395 if (*mac_addr == NULL) {
396 CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed");
399 return CONNECTION_ERROR_OUT_OF_MEMORY;
401 g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1);
405 *mac_addr = vconf_get_str(VCONFKEY_WIFI_BSSID_ADDRESS);
407 if (*mac_addr == NULL) {
408 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get vconf from %s", VCONFKEY_WIFI_BSSID_ADDRESS); //LCOV_EXCL_LINE
409 CONN_UNLOCK; //LCOV_EXCL_LINE
410 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
415 case CONNECTION_TYPE_ETHERNET:
416 fp = fopen(ETHERNET_MAC_INFO_FILE, "r");
418 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", ETHERNET_MAC_INFO_FILE);
420 return CONNECTION_ERROR_OUT_OF_MEMORY;
423 if (fgets(buf, sizeof(buf), fp) == NULL) {
424 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", ETHERNET_MAC_INFO_FILE);
427 return CONNECTION_ERROR_OPERATION_FAILED;
430 CONNECTION_LOG(CONNECTION_INFO, "%s : %s", ETHERNET_MAC_INFO_FILE, buf);
432 *mac_addr = (char *)malloc(CONNECTION_MAC_INFO_LENGTH + 1);
433 if (*mac_addr == NULL) {
434 CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed");
437 return CONNECTION_ERROR_OUT_OF_MEMORY;
440 g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1);
446 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
447 CONN_UNLOCK; //LCOV_EXCL_LINE
448 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
451 /* Checking Invalid MAC Address */
452 if ((strcmp(*mac_addr, "00:00:00:00:00:00") == 0) ||
453 (strcmp(*mac_addr, "ff:ff:ff:ff:ff:ff") == 0)) {
454 CONNECTION_LOG(CONNECTION_ERROR, "MAC Address(%s) is invalid", *mac_addr); //LCOV_EXCL_LINE
455 CONN_UNLOCK; //LCOV_EXCL_LINE
456 return CONNECTION_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
459 CONNECTION_LOG(CONNECTION_INFO, "MAC Address %s", *mac_addr);
462 return CONNECTION_ERROR_NONE;
466 EXPORT_API int connection_is_metered_network(connection_h connection, bool* is_metered)
470 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
472 if (is_metered == NULL || !(__connection_check_handle_validity(connection))) {
473 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
475 return CONNECTION_ERROR_INVALID_PARAMETER;
478 int rv = _connection_libnet_get_metered_state(connection, is_metered);
479 if (rv != CONNECTION_ERROR_NONE) {
480 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get metered state[%d]", rv); //LCOV_EXCL_LINE
481 CONN_UNLOCK; //LCOV_EXCL_LINE
482 return rv; //LCOV_EXCL_LINE
485 CONNECTION_LOG(CONNECTION_INFO, "metered state: %s", is_metered ? "true" : "false");
487 return CONNECTION_ERROR_NONE;
491 EXPORT_API int connection_get_cellular_state(connection_h connection, connection_cellular_state_e* state)
495 int cellular_state = 0;
496 #if defined TIZEN_DUALSIM_ENABLE
502 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
504 if (state == NULL || !(__connection_check_handle_validity(connection))) {
505 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
507 return CONNECTION_ERROR_INVALID_PARAMETER;
510 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &status);
511 if (rv != VCONF_OK) {
512 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
513 CONN_UNLOCK; //LCOV_EXCL_LINE
514 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
517 CONNECTION_LOG(CONNECTION_INFO, "Cellular: %d", status);
518 *state = __connection_convert_cellular_state(status);
520 if (*state == CONNECTION_CELLULAR_STATE_AVAILABLE) {
521 #if defined TIZEN_DUALSIM_ENABLE
522 rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
523 if (rv != VCONF_OK) {
524 CONNECTION_LOG(CONNECTION_ERROR,
525 "Failed to get default subscriber id", sim_id);
527 return CONNECTION_ERROR_OPERATION_FAILED;
531 case CONNECTION_CELLULAR_SUBSCRIBER_1:
533 rv = vconf_get_int(VCONFKEY_DNET_STATE, &cellular_state);
534 #if defined TIZEN_DUALSIM_ENABLE
537 case CONNECTION_CELLULAR_SUBSCRIBER_2:
538 rv = vconf_get_int(VCONFKEY_DNET_STATE2, &cellular_state);
542 CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
544 return CONNECTION_ERROR_OPERATION_FAILED;
547 if (rv != VCONF_OK) {
548 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
549 CONN_UNLOCK; //LCOV_EXCL_LINE
550 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
554 CONNECTION_LOG(CONNECTION_INFO, "Cellular state: %d", cellular_state);
556 if (cellular_state == VCONFKEY_DNET_NORMAL_CONNECTED ||
557 cellular_state == VCONFKEY_DNET_SECURE_CONNECTED ||
558 cellular_state == VCONFKEY_DNET_TRANSFER)
559 *state = CONNECTION_CELLULAR_STATE_CONNECTED;
562 return CONNECTION_ERROR_NONE;
565 EXPORT_API int connection_get_wifi_state(connection_h connection, connection_wifi_state_e* state)
569 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
571 if (state == NULL || !(__connection_check_handle_validity(connection))) {
572 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
574 return CONNECTION_ERROR_INVALID_PARAMETER;
577 int rv = _connection_libnet_get_wifi_state(connection, state);
578 if (rv != CONNECTION_ERROR_NONE) {
579 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get Wi-Fi state[%d]", rv); //LCOV_EXCL_LINE
580 CONN_UNLOCK; //LCOV_EXCL_LINE
581 return rv; //LCOV_EXCL_LINE
584 CONNECTION_LOG(CONNECTION_INFO, "Wi-Fi state: %d", *state);
587 return CONNECTION_ERROR_NONE;
591 EXPORT_API int connection_get_ethernet_state(connection_h connection, connection_ethernet_state_e *state)
595 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
597 if (state == NULL || !(__connection_check_handle_validity(connection))) {
598 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
600 return CONNECTION_ERROR_INVALID_PARAMETER;
603 int rv = _connection_libnet_get_ethernet_state(connection, state);
604 if (rv != CONNECTION_ERROR_NONE) {
605 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get ethernet state[%d]", rv); //LCOV_EXCL_LINE
607 return rv; //LCOV_EXCL_LINE
611 return CONNECTION_ERROR_NONE;
614 EXPORT_API int connection_get_ethernet_cable_state(connection_h connection, connection_ethernet_cable_state_e *state)
618 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
620 if (state == NULL || !(__connection_check_handle_validity(connection))) {
621 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
623 return CONNECTION_ERROR_INVALID_PARAMETER;
626 int rv = _connection_libnet_get_ethernet_cable_state(connection, state);
627 if (rv != CONNECTION_ERROR_NONE) {
628 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get ethernet cable state[%d]", rv); //LCOV_EXCL_LINE
630 return rv; //LCOV_EXCL_LINE
634 return CONNECTION_ERROR_NONE;
637 EXPORT_API int connection_set_ethernet_cable_state_chaged_cb(connection_h connection,
638 connection_ethernet_cable_state_chaged_cb callback, void *user_data)
640 DEPRECATED_LOG(__FUNCTION__, "connection_set_ethernet_cable_state_changed_cb");
644 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
646 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
647 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
649 return CONNECTION_ERROR_INVALID_PARAMETER;
652 DEPRECATED_LOG("connection_ethernet_cable_state_chaged_cb",
653 "connection_ethernet_cable_state_changed_cb");
655 __connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data);
658 return CONNECTION_ERROR_NONE;
661 EXPORT_API int connection_unset_ethernet_cable_state_chaged_cb(connection_h connection)
663 DEPRECATED_LOG(__FUNCTION__, "connection_unset_ethernet_cable_state_changed_cb");
667 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
669 if (!(__connection_check_handle_validity(connection))) {
670 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
672 return CONNECTION_ERROR_INVALID_PARAMETER;
675 __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
678 return CONNECTION_ERROR_NONE;
681 EXPORT_API int connection_set_ethernet_cable_state_changed_cb(connection_h connection,
682 connection_ethernet_cable_state_changed_cb callback, void *user_data)
686 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
688 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
689 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
691 return CONNECTION_ERROR_INVALID_PARAMETER;
694 __connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data);
697 return CONNECTION_ERROR_NONE;
700 EXPORT_API int connection_unset_ethernet_cable_state_changed_cb(connection_h connection)
704 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
706 if (!(__connection_check_handle_validity(connection))) {
707 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
709 return CONNECTION_ERROR_INVALID_PARAMETER;
712 __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
715 return CONNECTION_ERROR_NONE;
719 EXPORT_API int connection_get_bt_state(connection_h connection, connection_bt_state_e *state)
723 CHECK_FEATURE_SUPPORTED(TETHERING_BLUETOOTH_FEATURE);
725 if (state == NULL || !(__connection_check_handle_validity(connection))) {
726 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
728 return CONNECTION_ERROR_INVALID_PARAMETER;
731 int rv = _connection_libnet_get_bluetooth_state(connection, state);
732 if (rv != CONNECTION_ERROR_NONE) {
733 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get bluetooth state[%d]", rv); //LCOV_EXCL_LINE
734 CONN_UNLOCK; //LCOV_EXCL_LINE
735 return rv; //LCOV_EXCL_LINE
739 return CONNECTION_ERROR_NONE;
742 EXPORT_API int connection_set_type_changed_cb(connection_h connection,
743 connection_type_changed_cb callback, void* user_data)
747 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
749 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
750 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
752 return CONNECTION_ERROR_INVALID_PARAMETER;
755 __connection_set_type_changed_callback(connection, callback, user_data);
758 return CONNECTION_ERROR_NONE;
761 EXPORT_API int connection_unset_type_changed_cb(connection_h connection)
765 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
767 if (!(__connection_check_handle_validity(connection))) {
768 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
770 return CONNECTION_ERROR_INVALID_PARAMETER;
773 __connection_set_type_changed_callback(connection, NULL, NULL);
776 return CONNECTION_ERROR_NONE;
779 EXPORT_API int connection_set_ip_address_changed_cb(connection_h connection,
780 connection_address_changed_cb callback, void* user_data)
784 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
786 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
787 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
789 return CONNECTION_ERROR_INVALID_PARAMETER;
792 __connection_set_ip_changed_callback(connection, callback, user_data);
795 return CONNECTION_ERROR_NONE;
798 EXPORT_API int connection_unset_ip_address_changed_cb(connection_h connection)
802 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
804 if (!(__connection_check_handle_validity(connection))) {
805 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
807 return CONNECTION_ERROR_INVALID_PARAMETER;
810 __connection_set_ip_changed_callback(connection, NULL, NULL);
813 return CONNECTION_ERROR_NONE;
816 EXPORT_API int connection_set_proxy_address_changed_cb(connection_h connection,
817 connection_address_changed_cb callback, void* user_data)
821 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
823 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
824 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
826 return CONNECTION_ERROR_INVALID_PARAMETER;
829 __connection_set_proxy_changed_callback(connection, callback, user_data);
832 return CONNECTION_ERROR_NONE;
835 EXPORT_API int connection_unset_proxy_address_changed_cb(connection_h connection)
839 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
841 if (!(__connection_check_handle_validity(connection))) {
842 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
844 return CONNECTION_ERROR_INVALID_PARAMETER;
847 __connection_set_proxy_changed_callback(connection, NULL, NULL);
850 return CONNECTION_ERROR_NONE;
853 EXPORT_API int connection_set_internet_state_changed_cb(connection_h connection,
854 connection_internet_state_changed_cb callback, void *user_data)
858 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
860 if (callback == NULL || !(__connection_check_handle_validity(connection))) {
861 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
863 return CONNECTION_ERROR_INVALID_PARAMETER;
866 __connection_set_internet_state_changed_callback(connection, callback, user_data);
869 return CONNECTION_ERROR_NONE;
872 EXPORT_API int connection_unset_internet_state_changed_cb(connection_h connection)
876 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
878 if (!(__connection_check_handle_validity(connection))) {
879 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
881 return CONNECTION_ERROR_INVALID_PARAMETER;
884 __connection_set_internet_state_changed_callback(connection, NULL, NULL);
887 return CONNECTION_ERROR_NONE;
890 EXPORT_API int connection_add_profile(connection_h connection, connection_profile_h profile)
893 connection_handle_s *conn_handle = (connection_handle_s *)connection;
894 net_profile_info_t *profile_info = (net_profile_info_t *)profile;
898 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
900 if (!(__connection_check_handle_validity(connection)) ||
901 !(_connection_libnet_check_profile_validity(profile))) {
902 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
904 return CONNECTION_ERROR_INVALID_PARAMETER;
907 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
908 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
909 CONN_UNLOCK; //LCOV_EXCL_LINE
910 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
913 if (profile_info->ProfileInfo.Pdp.PSModemPath[0] != '/' ||
914 strlen(profile_info->ProfileInfo.Pdp.PSModemPath) < 2) {
915 CONNECTION_LOG(CONNECTION_ERROR, "Modem object path is NULL"); //LCOV_EXCL_LINE
916 CONN_UNLOCK; //LCOV_EXCL_LINE
917 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
920 rv = net_add_profile(conn_handle->network_info_handle,
921 profile_info->ProfileInfo.Pdp.ServiceType, profile_info);
922 if (rv == NET_ERR_ACCESS_DENIED) {
923 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
924 CONN_UNLOCK; //LCOV_EXCL_LINE
925 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
926 } else if (rv != NET_ERR_NONE) {
927 CONNECTION_LOG(CONNECTION_ERROR, "Failed to add profile[%d]", rv); //LCOV_EXCL_LINE
928 CONN_UNLOCK; //LCOV_EXCL_LINE
929 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
933 return CONNECTION_ERROR_NONE;
936 EXPORT_API int connection_remove_profile(connection_h connection, connection_profile_h profile)
939 connection_handle_s *conn_handle = (connection_handle_s *)connection;
940 net_profile_info_t *profile_info = (net_profile_info_t *)profile;
944 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
946 if (!(__connection_check_handle_validity(connection)) ||
947 !(_connection_libnet_check_profile_validity(profile))) {
948 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
950 return CONNECTION_ERROR_INVALID_PARAMETER;
953 if (profile_info->profile_type != NET_DEVICE_CELLULAR &&
954 profile_info->profile_type != NET_DEVICE_MESH &&
955 profile_info->profile_type != NET_DEVICE_WIFI) {
956 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
957 CONN_UNLOCK; //LCOV_EXCL_LINE
958 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
961 rv = net_delete_profile(conn_handle->network_info_handle, profile_info->ProfileName);
962 if (rv == NET_ERR_ACCESS_DENIED) {
963 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
964 CONN_UNLOCK; //LCOV_EXCL_LINE
965 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
966 } else if (rv != NET_ERR_NONE) {
967 CONNECTION_LOG(CONNECTION_ERROR, "Failed to delete profile[%d]", rv); //LCOV_EXCL_LINE
968 CONN_UNLOCK; //LCOV_EXCL_LINE
969 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
973 return CONNECTION_ERROR_NONE;
976 EXPORT_API int connection_update_profile(connection_h connection, connection_profile_h profile)
979 connection_handle_s *conn_handle = (connection_handle_s *)connection;
980 net_profile_info_t *profile_info = (net_profile_info_t *)profile;
984 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
986 if (!(__connection_check_handle_validity(connection)) ||
987 !(_connection_libnet_check_profile_validity(profile))) {
988 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
990 return CONNECTION_ERROR_INVALID_PARAMETER;
993 rv = net_modify_profile(conn_handle->network_info_handle,
994 profile_info->ProfileName, (net_profile_info_t*)profile);
995 if (rv == NET_ERR_ACCESS_DENIED) {
996 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
997 CONN_UNLOCK; //LCOV_EXCL_LINE
998 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
999 } else if (rv != NET_ERR_NONE) {
1000 CONNECTION_LOG(CONNECTION_ERROR, "Failed to modify profile[%d]", rv); //LCOV_EXCL_LINE
1001 CONN_UNLOCK; //LCOV_EXCL_LINE
1002 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1006 return CONNECTION_ERROR_NONE;
1009 EXPORT_API int connection_get_profile_iterator(connection_h connection,
1010 connection_iterator_type_e type, connection_profile_iterator_h* profile_iterator)
1014 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1016 if (!(__connection_check_handle_validity(connection)) ||
1017 (type != CONNECTION_ITERATOR_TYPE_REGISTERED &&
1018 type != CONNECTION_ITERATOR_TYPE_CONNECTED &&
1019 type != CONNECTION_ITERATOR_TYPE_DEFAULT)) {
1020 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1022 return CONNECTION_ERROR_INVALID_PARAMETER;
1025 int rv = _connection_libnet_get_profile_iterator(connection, type, profile_iterator);
1026 if (rv != CONNECTION_ERROR_NONE) {
1027 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get profile iterator [%d]", rv); //LCOV_EXCL_LINE
1028 CONN_UNLOCK; //LCOV_EXCL_LINE
1029 return rv; //LCOV_EXCL_LINE
1033 return CONNECTION_ERROR_NONE;
1036 EXPORT_API int connection_profile_iterator_next(connection_profile_iterator_h profile_iterator,
1037 connection_profile_h* profile)
1041 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1043 int rv = _connection_libnet_get_iterator_next(profile_iterator, profile);
1049 EXPORT_API bool connection_profile_iterator_has_next(connection_profile_iterator_h profile_iterator)
1053 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1055 int rv = _connection_libnet_iterator_has_next(profile_iterator);
1061 EXPORT_API int connection_destroy_profile_iterator(connection_profile_iterator_h profile_iterator)
1065 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1067 int rv = _connection_libnet_destroy_iterator(profile_iterator);
1073 EXPORT_API int connection_get_current_profile(connection_h connection, connection_profile_h* profile)
1077 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_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_get_current_profile(connection, profile);
1086 if (rv != CONNECTION_ERROR_NONE) {
1087 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get current profile [%d]", rv); //LCOV_EXCL_LINE
1088 CONN_UNLOCK; //LCOV_EXCL_LINE
1089 return rv; //LCOV_EXCL_LINE
1093 return CONNECTION_ERROR_NONE;
1096 EXPORT_API int connection_get_default_cellular_service_profile(
1097 connection_h connection, connection_cellular_service_type_e type,
1098 connection_profile_h *profile)
1102 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1104 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1105 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1107 return CONNECTION_ERROR_INVALID_PARAMETER;
1110 int rv = _connection_libnet_get_cellular_service_profile(connection, type, profile);
1111 if (rv != CONNECTION_ERROR_NONE) {
1112 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get default cellular service profile [%d]", rv); //LCOV_EXCL_LINE
1113 CONN_UNLOCK; //LCOV_EXCL_LINE
1114 return rv; //LCOV_EXCL_LINE
1118 return CONNECTION_ERROR_NONE;
1121 EXPORT_API int connection_set_default_cellular_service_profile(connection_h connection,
1122 connection_cellular_service_type_e type, connection_profile_h profile)
1126 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1128 if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1129 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1131 return CONNECTION_ERROR_INVALID_PARAMETER;
1134 int rv = _connection_libnet_set_cellular_service_profile_sync(connection, type, profile);
1135 if (rv != CONNECTION_ERROR_NONE) {
1136 CONNECTION_LOG(CONNECTION_ERROR, "Fail to set default cellular service profile [%d]", rv); //LCOV_EXCL_LINE
1137 CONN_UNLOCK; //LCOV_EXCL_LINE
1138 return rv; //LCOV_EXCL_LINE
1142 return CONNECTION_ERROR_NONE;
1145 EXPORT_API int connection_set_default_cellular_service_profile_async(connection_h connection,
1146 connection_cellular_service_type_e type, connection_profile_h profile,
1147 connection_set_default_cb callback, void* user_data)
1151 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1155 if (!(__connection_check_handle_validity(connection)) ||
1156 profile == NULL || callback == NULL) {
1157 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1159 return CONNECTION_ERROR_INVALID_PARAMETER;
1162 rv = _connection_libnet_set_cellular_service_profile_async(connection, type, profile);
1163 if (rv == NET_ERR_ACCESS_DENIED) {
1164 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1165 CONN_UNLOCK; //LCOV_EXCL_LINE
1166 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1167 } else if (rv != NET_ERR_NONE) {
1168 CONNECTION_LOG(CONNECTION_ERROR, "Failed to set default cellular service profile[%d]", rv); //LCOV_EXCL_LINE
1169 CONN_UNLOCK; //LCOV_EXCL_LINE
1170 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1173 __connection_set_default_cellular_service_profile_callback(connection, callback, user_data);
1176 return CONNECTION_ERROR_NONE;
1179 EXPORT_API int connection_open_profile(connection_h connection, connection_profile_h profile,
1180 connection_opened_cb callback, void* user_data)
1184 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1188 if (!(__connection_check_handle_validity(connection)) ||
1189 profile == NULL || callback == NULL) {
1190 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1192 return CONNECTION_ERROR_INVALID_PARAMETER;
1195 rv = _connection_libnet_open_profile(connection, profile);
1196 if (rv == NET_ERR_ACCESS_DENIED) {
1197 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1198 CONN_UNLOCK; //LCOV_EXCL_LINE
1199 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1200 } else if (rv != NET_ERR_NONE) {
1201 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open profile[%d]", rv); //LCOV_EXCL_LINE
1202 CONN_UNLOCK; //LCOV_EXCL_LINE
1203 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1206 __connection_open_profile_set_callback(connection, callback, user_data);
1209 return CONNECTION_ERROR_NONE;
1212 EXPORT_API int connection_close_profile(connection_h connection, connection_profile_h profile,
1213 connection_closed_cb callback, void* user_data)
1217 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1221 if (!(__connection_check_handle_validity(connection)) ||
1222 profile == NULL || callback == NULL) {
1223 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1225 return CONNECTION_ERROR_INVALID_PARAMETER;
1228 rv = _connection_libnet_close_profile(connection, profile);
1229 if (rv == NET_ERR_ACCESS_DENIED) {
1230 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1231 CONN_UNLOCK; //LCOV_EXCL_LINE
1232 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1233 } else if (rv != NET_ERR_NONE) {
1234 CONNECTION_LOG(CONNECTION_ERROR, "Failed to close profile[%d]", rv); //LCOV_EXCL_LINE
1235 CONN_UNLOCK; //LCOV_EXCL_LINE
1236 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1239 __connection_close_profile_set_callback(connection, callback, user_data);
1242 return CONNECTION_ERROR_NONE;
1245 EXPORT_API int connection_reset_profile(connection_h connection,
1246 connection_reset_option_e type, int id, connection_reset_cb callback, void *user_data)
1250 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1254 if (!(__connection_check_handle_validity(connection))) {
1255 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
1257 return CONNECTION_ERROR_INVALID_PARAMETER;
1260 if (id < 0 || id > 1) {
1261 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed"); //LCOV_EXCL_LINE
1262 CONN_UNLOCK; //LCOV_EXCL_LINE
1263 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1266 rv = _connection_libnet_reset_profile(connection, type, id);
1267 if (rv == NET_ERR_ACCESS_DENIED) {
1268 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1269 CONN_UNLOCK; //LCOV_EXCL_LINE
1270 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1271 } else if (rv != NET_ERR_NONE) {
1272 CONNECTION_LOG(CONNECTION_ERROR, "Failed to reset profile[%d]", rv); //LCOV_EXCL_LINE
1273 CONN_UNLOCK; //LCOV_EXCL_LINE
1274 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1277 __connection_reset_profile_set_callback(connection, callback, user_data);
1280 return CONNECTION_ERROR_NONE;
1283 EXPORT_API int connection_add_route(connection_h connection, const char* interface_name, const char* host_address)
1287 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1289 if (!(__connection_check_handle_validity(connection)) ||
1290 interface_name == NULL || host_address == NULL) {
1291 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1293 return CONNECTION_ERROR_INVALID_PARAMETER;
1296 int rv = _connection_libnet_add_route(connection, interface_name, host_address);
1297 if (rv != CONNECTION_ERROR_NONE) {
1298 CONNECTION_LOG(CONNECTION_ERROR, "Fail to add route [%d]", rv); //LCOV_EXCL_LINE
1299 CONN_UNLOCK; //LCOV_EXCL_LINE
1300 return rv; //LCOV_EXCL_LINE
1304 return CONNECTION_ERROR_NONE;
1307 EXPORT_API int connection_remove_route(connection_h connection, const char* interface_name, const char* host_address)
1311 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1313 if (!(__connection_check_handle_validity(connection)) ||
1314 interface_name == NULL || host_address == NULL) {
1315 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1317 return CONNECTION_ERROR_INVALID_PARAMETER;
1320 int rv = _connection_libnet_remove_route(connection, interface_name, host_address);
1321 if (rv != CONNECTION_ERROR_NONE) {
1322 CONNECTION_LOG(CONNECTION_ERROR, "Fail to remove route [%d]", rv); //LCOV_EXCL_LINE
1323 CONN_UNLOCK; //LCOV_EXCL_LINE
1324 return rv; //LCOV_EXCL_LINE
1328 return CONNECTION_ERROR_NONE;
1331 EXPORT_API int connection_add_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1335 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1337 if (!(__connection_check_handle_validity(connection)) ||
1338 interface_name == NULL || host_address == NULL) {
1339 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1341 return CONNECTION_ERROR_INVALID_PARAMETER;
1344 int rv = _connection_libnet_add_route_ipv6(connection, interface_name, host_address, gateway);
1345 if (rv != CONNECTION_ERROR_NONE) {
1346 CONNECTION_LOG(CONNECTION_ERROR, "Fail to add route ipv6 [%d]", rv); //LCOV_EXCL_LINE
1347 CONN_UNLOCK; //LCOV_EXCL_LINE
1348 return rv; //LCOV_EXCL_LINE
1352 return CONNECTION_ERROR_NONE;
1355 EXPORT_API int connection_remove_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1359 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1361 if (!(__connection_check_handle_validity(connection)) ||
1362 interface_name == NULL || host_address == NULL) {
1363 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1365 return CONNECTION_ERROR_INVALID_PARAMETER;
1368 int rv = _connection_libnet_remove_route_ipv6(connection, interface_name, host_address, gateway);
1369 if (rv != CONNECTION_ERROR_NONE) {
1370 CONNECTION_LOG(CONNECTION_ERROR, "Fail to remove route ipv6 [%d]", rv); //LCOV_EXCL_LINE
1371 CONN_UNLOCK; //LCOV_EXCL_LINE
1372 return rv; //LCOV_EXCL_LINE
1376 return CONNECTION_ERROR_NONE;
1379 EXPORT_API int connection_add_route_entry(connection_h connection,
1380 connection_address_family_e address_family, const char *interface_name,
1381 const char *host_address, const char *gateway)
1385 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1387 if (!(__connection_check_handle_validity(connection)) ||
1388 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1389 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1390 interface_name == NULL || host_address == NULL) {
1391 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1393 return CONNECTION_ERROR_INVALID_PARAMETER;
1396 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1397 int rv = _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
1398 interface_name, host_address, gateway);
1402 int rv = _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
1403 interface_name, host_address, gateway);
1409 EXPORT_API int connection_remove_route_entry(connection_h connection,
1410 connection_address_family_e address_family, const char *interface_name,
1411 const char *host_address, const char *gateway)
1415 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1417 if (!(__connection_check_handle_validity(connection)) ||
1418 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1419 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1420 interface_name == NULL || host_address == NULL) {
1421 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1423 return CONNECTION_ERROR_INVALID_PARAMETER;
1426 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1427 int rv = _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
1428 interface_name, host_address, gateway);
1432 int rv = _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
1433 interface_name, host_address, gateway);
1439 static int __get_cellular_statistic(connection_statistics_type_e statistics_type, long long *llsize)
1441 int rv = VCONF_OK, rv1 = VCONF_OK;
1442 int last_size = 0, size = 0;
1443 #if defined TIZEN_DUALSIM_ENABLE
1447 if (llsize == NULL) {
1448 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1449 return CONNECTION_ERROR_INVALID_PARAMETER;
1452 switch (statistics_type) {
1453 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1454 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1455 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1456 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1459 return CONNECTION_ERROR_INVALID_PARAMETER;
1462 #if defined TIZEN_DUALSIM_ENABLE
1463 rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
1464 if (rv != VCONF_OK) {
1465 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get default subscriber id");
1467 return CONNECTION_ERROR_OPERATION_FAILED;
1473 switch (statistics_type) {
1474 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1475 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1477 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1478 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1480 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1481 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1482 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT, &size);
1484 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1485 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1486 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV, &size);
1489 #if defined TIZEN_DUALSIM_ENABLE
1492 switch (statistics_type) {
1493 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1494 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1496 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1497 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1499 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1500 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1501 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT2, &size);
1503 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1504 rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1505 rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV2, &size);
1511 CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
1512 return CONNECTION_ERROR_OPERATION_FAILED;
1516 if (rv != VCONF_OK || rv1 != VCONF_OK) {
1517 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular statistics"); //LCOV_EXCL_LINE
1518 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1521 *llsize = (long long)(last_size * 1000) + (long long)(size * 1000);
1522 CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", *llsize);
1524 return CONNECTION_ERROR_NONE;
1527 static int __get_statistic(connection_handle_s *conn_handle, connection_type_e connection_type,
1528 connection_statistics_type_e statistics_type, long long *llsize)
1531 unsigned long long ull_size;
1533 if (llsize == NULL) {
1534 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1535 return CONNECTION_ERROR_INVALID_PARAMETER;
1538 rv = _connection_libnet_check_get_privilege();
1539 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1541 else if (rv != CONNECTION_ERROR_NONE) {
1542 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get statistics"); //LCOV_EXCL_LINE
1543 return CONNECTION_ERROR_OPERATION_FAILED;
1546 if (connection_type == CONNECTION_TYPE_CELLULAR)
1547 return __get_cellular_statistic(statistics_type, llsize);
1548 else if (connection_type == CONNECTION_TYPE_WIFI) {
1549 switch (statistics_type) {
1550 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1551 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1553 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1554 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1556 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1557 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1559 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1560 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1563 return CONNECTION_ERROR_INVALID_PARAMETER;
1566 rv = _connection_libnet_get_statistics(conn_handle, stat_type, &ull_size);
1567 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1569 else if (rv != CONNECTION_ERROR_NONE) {
1570 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get Wi-Fi statistics"); //LCOV_EXCL_LINE
1571 *llsize = 0; //LCOV_EXCL_LINE
1572 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1575 CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", ull_size);
1576 *llsize = (long long)ull_size;
1578 return CONNECTION_ERROR_INVALID_PARAMETER;
1580 return CONNECTION_ERROR_NONE;
1583 static int __reset_statistic(connection_handle_s *conn_handle,
1584 connection_type_e connection_type, connection_statistics_type_e statistics_type)
1590 if (connection_type == CONNECTION_TYPE_CELLULAR)
1591 conn_type = NET_DEVICE_CELLULAR;
1592 else if (connection_type == CONNECTION_TYPE_WIFI)
1593 conn_type = NET_DEVICE_WIFI;
1595 return CONNECTION_ERROR_INVALID_PARAMETER;
1597 switch (statistics_type) {
1598 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1599 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1601 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1602 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1604 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1605 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1607 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1608 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1611 return CONNECTION_ERROR_INVALID_PARAMETER;
1614 rv = _connection_libnet_set_statistics(conn_handle, conn_type, stat_type);
1615 if (rv != CONNECTION_ERROR_NONE)
1618 CONNECTION_LOG(CONNECTION_INFO, "connection_reset_statistics success");
1620 return CONNECTION_ERROR_NONE;
1623 EXPORT_API int connection_get_statistics(connection_h connection,
1624 connection_type_e connection_type,
1625 connection_statistics_type_e statistics_type, long long* size)
1629 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1631 if (connection_type == CONNECTION_TYPE_CELLULAR)
1632 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1633 else if (connection_type == CONNECTION_TYPE_WIFI)
1634 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1636 if (!(__connection_check_handle_validity(connection)) || size == NULL) {
1637 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1639 return CONNECTION_ERROR_INVALID_PARAMETER;
1642 int rv = __get_statistic(connection, connection_type, statistics_type, size);
1643 if (rv != CONNECTION_ERROR_NONE) {
1644 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get statistics [%d]", rv); //LCOV_EXCL_LINE
1646 return rv; //LCOV_EXCL_LINE
1650 return CONNECTION_ERROR_NONE;
1653 EXPORT_API int connection_reset_statistics(connection_h connection,
1654 connection_type_e connection_type,
1655 connection_statistics_type_e statistics_type)
1659 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1661 if (connection_type == CONNECTION_TYPE_CELLULAR)
1662 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1663 else if (connection_type == CONNECTION_TYPE_WIFI)
1664 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1666 if (!__connection_check_handle_validity(connection)) {
1667 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1669 return CONNECTION_ERROR_INVALID_PARAMETER;
1672 int rv = __reset_statistic(connection, connection_type, statistics_type);
1673 if (rv != CONNECTION_ERROR_NONE) {
1674 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get statistics [%d]", rv); //LCOV_EXCL_LINE
1676 return rv; //LCOV_EXCL_LINE
1680 return CONNECTION_ERROR_NONE;
1683 EXPORT_API int connection_foreach_ipv6_address(connection_h connection,
1684 connection_type_e connection_type, connection_ipv6_address_cb callback,
1689 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1690 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1692 GSList *ipv6_address_list = NULL;
1694 if (!(__connection_check_handle_validity(connection))) {
1695 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1697 return CONNECTION_ERROR_INVALID_PARAMETER;
1700 int rv = CONNECTION_ERROR_NONE;
1702 switch (connection_type) {
1703 case CONNECTION_TYPE_WIFI:
1704 rv = net_foreach_ipv6_address(NET_DEVICE_WIFI,
1705 &ipv6_address_list);
1707 case CONNECTION_TYPE_CELLULAR:
1708 rv = net_foreach_ipv6_address(NET_DEVICE_CELLULAR,
1709 &ipv6_address_list);
1711 case CONNECTION_TYPE_ETHERNET:
1712 rv = net_foreach_ipv6_address(NET_DEVICE_ETHERNET,
1713 &ipv6_address_list);
1715 case CONNECTION_TYPE_BT:
1716 rv = net_foreach_ipv6_address(NET_DEVICE_BLUETOOTH,
1717 &ipv6_address_list);
1720 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1722 return CONNECTION_ERROR_INVALID_PARAMETER;
1725 if (rv != NET_ERR_NONE) {
1726 CONNECTION_LOG(CONNECTION_ERROR, "net_get_multiple_id_address" //LCOV_EXCL_LINE
1727 " Failed = %d\n", rv);
1728 CONN_UNLOCK; //LCOV_EXCL_LINE
1729 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1733 for (list = ipv6_address_list; list; list = list->next) {
1734 rv = callback((char *)list->data, user_data);
1739 g_slist_free_full(ipv6_address_list, g_free);
1740 ipv6_address_list = NULL;
1743 return CONNECTION_ERROR_NONE;
1746 EXPORT_API int connection_profile_start_tcpdump(connection_h connection)
1752 if (!(__connection_check_handle_validity(connection))) {
1753 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1755 return CONNECTION_ERROR_INVALID_PARAMETER;
1758 ret = _connection_libnet_start_tcpdump(connection);
1759 if (ret != CONNECTION_ERROR_NONE) {
1760 CONNECTION_LOG(CONNECTION_ERROR, "Failed to start tcpdump (%d)", ret);
1766 return CONNECTION_ERROR_NONE;
1769 EXPORT_API int connection_profile_stop_tcpdump(connection_h connection)
1775 if (!(__connection_check_handle_validity(connection))) {
1776 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1778 return CONNECTION_ERROR_INVALID_PARAMETER;
1781 ret = _connection_libnet_stop_tcpdump(connection);
1782 if (ret != CONNECTION_ERROR_NONE) {
1783 CONNECTION_LOG(CONNECTION_ERROR, "Failed to stop tcpdump (%d)", ret);
1789 return CONNECTION_ERROR_NONE;
1792 EXPORT_API int connection_profile_get_tcpdump_state(connection_h connection, gboolean *tcpdump_state)
1798 if (!(__connection_check_handle_validity(connection)) || !tcpdump_state) {
1799 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1801 return CONNECTION_ERROR_INVALID_PARAMETER;
1804 ret = _connection_libnet_get_tcpdump_state(connection, tcpdump_state);
1805 if (ret != CONNECTION_ERROR_NONE) {
1806 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get the tcpdump state (%d)", ret);
1812 return CONNECTION_ERROR_NONE;