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 <arpa/inet.h>
22 #include <vconf/vconf.h>
24 #include "net_connection_private.h"
25 #include "connection_extension.h"
27 #define HTTP_PROXY "http_proxy"
28 #define MAX_PREFIX_LENGTH 6
30 static net_dev_info_t* __profile_get_net_info(net_profile_info_t *profile_info)
32 switch (profile_info->profile_type) {
33 case NET_DEVICE_CELLULAR:
34 return &profile_info->ProfileInfo.Pdp.net_info;
36 return &profile_info->ProfileInfo.Wlan.net_info;
37 case NET_DEVICE_ETHERNET:
38 return &profile_info->ProfileInfo.Ethernet.net_info; //LCOV_EXCL_LINE
39 case NET_DEVICE_BLUETOOTH:
40 return &profile_info->ProfileInfo.Bluetooth.net_info;
42 return &profile_info->ProfileInfo.Mesh.net_info;
43 case NET_DEVICE_DEFAULT:
45 case NET_DEVICE_UNKNOWN:
52 static char *__profile_convert_ip_to_string(net_addr_t *ip_addr, connection_address_family_e address_family)
54 unsigned char *ipaddr = NULL;
57 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
58 ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
59 ipstr = g_try_malloc0(INET_ADDRSTRLEN);
63 inet_ntop(AF_INET, ipaddr, ipstr, INET_ADDRSTRLEN);
66 ipaddr = (unsigned char *)&ip_addr->Data.Ipv6.s6_addr;
67 ipstr = g_try_malloc0(INET6_ADDRSTRLEN);
71 inet_ntop(AF_INET6, ipaddr, ipstr, INET6_ADDRSTRLEN);
78 static void __profile_init_cellular_profile(net_profile_info_t *profile_info, const char *keyword)
80 int default_subscriber_id = 0;
81 connection_profile_h profile = NULL;
83 profile_info->profile_type = NET_DEVICE_CELLULAR;
84 profile_info->ProfileState = NET_STATE_TYPE_IDLE;
85 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_UNKNOWN;
86 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_UNKNOWN;
87 profile_info->ProfileInfo.Pdp.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
88 profile_info->ProfileInfo.Pdp.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
89 g_strlcpy(profile_info->ProfileInfo.Pdp.Keyword, keyword, NET_PDP_APN_LEN_MAX);
91 if (vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE,
92 &default_subscriber_id) != 0)
93 CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
94 "Failed to get VCONF_TELEPHONY_DEFAULT_DATA_SERVICE");
96 profile = (connection_profile_h)profile_info;
97 _connection_libnet_set_cellular_subscriber_id(profile, default_subscriber_id);
100 static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
102 profile_info->profile_type = NET_DEVICE_WIFI;
103 profile_info->ProfileState = NET_STATE_TYPE_IDLE;
104 profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
105 profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
106 profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
107 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
108 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
112 static char* __profile_get_ethernet_proxy(void)
116 proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
119 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
127 static unsigned char __profile_convert_netmask_to_prefix_len(const char *netmask)
132 in_addr_t mask = inet_network(netmask);
133 in_addr_t host = ~mask;
134 unsigned char prefix_len = 0;
136 /* a valid netmask must be 2^n - 1 */
137 if ((host & (host + 1)) != 0)
140 for (; mask; mask <<= 1)
146 static in_addr_t __profile_convert_prefix_len_to_netmask(int prefix_len)
148 return (prefix_len ? (in_addr_t) 0xFFFFFFFFu >> (32 - prefix_len) : 0);
152 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
155 case NET_SERVICE_INTERNET:
156 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
157 case NET_SERVICE_MMS:
158 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
159 case NET_SERVICE_PREPAID_INTERNET:
160 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
161 case NET_SERVICE_PREPAID_MMS:
162 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
163 case NET_SERVICE_TETHERING:
164 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
165 case NET_SERVICE_APPLICATION:
166 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
168 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
172 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
174 connection_profile_state_e cp_state;
177 case NET_STATE_TYPE_ONLINE:
178 case NET_STATE_TYPE_READY:
179 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
181 case NET_STATE_TYPE_IDLE:
182 case NET_STATE_TYPE_FAILURE:
183 case NET_STATE_TYPE_DISCONNECT:
184 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
186 case NET_STATE_TYPE_ASSOCIATION:
187 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
189 case NET_STATE_TYPE_CONFIGURATION:
190 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
199 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
202 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
203 return NET_SERVICE_INTERNET;
204 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
205 return NET_SERVICE_MMS;
206 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
207 return NET_SERVICE_PREPAID_INTERNET;
208 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
209 return NET_SERVICE_PREPAID_MMS;
210 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
211 return NET_SERVICE_TETHERING;
212 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
213 return NET_SERVICE_APPLICATION;
215 return NET_SERVICE_UNKNOWN;
219 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
221 net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
224 case CONNECTION_PROFILE_STATE_CONNECTED:
225 libnet_state = NET_STATE_TYPE_ONLINE;
227 case CONNECTION_PROFILE_STATE_DISCONNECTED:
228 libnet_state = NET_STATE_TYPE_IDLE;
230 case CONNECTION_PROFILE_STATE_ASSOCIATION:
231 libnet_state = NET_STATE_TYPE_ASSOCIATION;
233 case CONNECTION_PROFILE_STATE_CONFIGURATION:
234 libnet_state = NET_STATE_TYPE_CONFIGURATION;
242 /* Connection profile ********************************************************/
243 EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
247 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
249 if (type == CONNECTION_PROFILE_TYPE_CELLULAR)
250 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
251 else if (type == CONNECTION_PROFILE_TYPE_WIFI)
252 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
254 if (type != CONNECTION_PROFILE_TYPE_CELLULAR &&
255 type != CONNECTION_PROFILE_TYPE_WIFI) {
256 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
258 return CONNECTION_ERROR_INVALID_PARAMETER;
261 if (profile == NULL) {
262 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
264 return CONNECTION_ERROR_INVALID_PARAMETER;
267 int rv = _connection_libnet_check_profile_privilege();
268 if (rv == CONNECTION_ERROR_PERMISSION_DENIED) {
269 CONN_UNLOCK; //LCOV_EXCL_LINE
270 return rv; //LCOV_EXCL_LINE
271 } else if (rv != CONNECTION_ERROR_NONE) {
272 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create profile"); //LCOV_EXCL_LINE
273 CONN_UNLOCK; //LCOV_EXCL_LINE
274 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
277 net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
278 if (profile_info == NULL) {
279 CONN_UNLOCK; //LCOV_EXCL_LINE
280 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
283 if (type == CONNECTION_PROFILE_TYPE_CELLULAR) {
284 if (keyword == NULL) {
285 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
286 g_free(profile_info);
288 return CONNECTION_ERROR_INVALID_PARAMETER;
290 __profile_init_cellular_profile(profile_info, keyword);
291 } else if (type == CONNECTION_PROFILE_TYPE_WIFI) {
292 __profile_init_wifi_profile(profile_info);
295 *profile = (connection_profile_h)profile_info;
296 _connection_libnet_add_to_profile_list(*profile);
299 return CONNECTION_ERROR_NONE;
302 EXPORT_API int connection_profile_destroy(connection_profile_h profile)
306 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
308 if (!(_connection_libnet_check_profile_validity(profile))) {
309 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
311 return CONNECTION_ERROR_INVALID_PARAMETER;
314 _connection_libnet_remove_from_profile_list(profile);
317 return CONNECTION_ERROR_NONE;
320 EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
324 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
326 if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
327 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
329 return CONNECTION_ERROR_INVALID_PARAMETER;
332 *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
333 if (*cloned_profile == NULL) {
334 CONN_UNLOCK; //LCOV_EXCL_LINE
335 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
338 memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
339 _connection_libnet_add_to_profile_list(*cloned_profile);
342 return CONNECTION_ERROR_NONE;
345 EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
349 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
351 if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
352 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
354 return CONNECTION_ERROR_INVALID_PARAMETER;
357 net_profile_info_t *profile_info = profile;
359 char *prof_id = strrchr(profile_info->ProfileName, '/');
360 if (prof_id == NULL) {
361 CONN_UNLOCK; //LCOV_EXCL_LINE
362 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
366 *profile_id = g_strdup(prof_id);
368 if (*profile_id == NULL) {
369 CONN_UNLOCK; //LCOV_EXCL_LINE
370 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
374 return CONNECTION_ERROR_NONE;
377 EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
381 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
383 if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
384 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
386 return CONNECTION_ERROR_INVALID_PARAMETER;
389 net_profile_info_t *profile_info = profile;
391 switch (profile_info->profile_type) {
392 case NET_DEVICE_CELLULAR:
393 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
395 case NET_DEVICE_WIFI:
396 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
398 case NET_DEVICE_ETHERNET:
399 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName); //LCOV_EXCL_LINE
400 break; //LCOV_EXCL_LINE
401 case NET_DEVICE_BLUETOOTH: {
402 char *bt_name = strrchr(profile_info->ProfileName, '/');
403 if (bt_name == NULL) {
404 CONN_UNLOCK; //LCOV_EXCL_LINE
405 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
409 *profile_name = g_strdup(bt_name);
411 case NET_DEVICE_MESH:
412 *profile_name = g_strdup(profile_info->ProfileInfo.Mesh.essid);
415 CONN_UNLOCK; //LCOV_EXCL_LINE
416 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
419 if (*profile_name == NULL) {
420 CONN_UNLOCK; //LCOV_EXCL_LINE
421 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
425 return CONNECTION_ERROR_NONE;
428 EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e *type)
432 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
434 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
435 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
437 return CONNECTION_ERROR_INVALID_PARAMETER;
440 net_profile_info_t *profile_info = profile;
442 switch (profile_info->profile_type) {
443 case NET_DEVICE_CELLULAR:
444 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
446 case NET_DEVICE_WIFI:
447 *type = CONNECTION_PROFILE_TYPE_WIFI;
449 case NET_DEVICE_ETHERNET:
450 *type = CONNECTION_PROFILE_TYPE_ETHERNET; //LCOV_EXCL_LINE
451 break; //LCOV_EXCL_LINE
452 case NET_DEVICE_BLUETOOTH:
453 *type = CONNECTION_PROFILE_TYPE_BT;
455 case NET_DEVICE_MESH:
456 *type = CONNECTION_PROFILE_TYPE_MESH;
459 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type"); //LCOV_EXCL_LINE
460 CONN_UNLOCK; //LCOV_EXCL_LINE
461 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
465 return CONNECTION_ERROR_NONE;
468 EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
472 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
474 if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
475 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
477 return CONNECTION_ERROR_INVALID_PARAMETER;
480 net_profile_info_t *profile_info = profile;
481 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
482 if (net_info == NULL) {
483 CONN_UNLOCK; //LCOV_EXCL_LINE
484 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
487 *interface_name = g_strdup(net_info->DevName);
488 if (*interface_name == NULL) {
489 CONN_UNLOCK; //LCOV_EXCL_LINE
490 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
494 return CONNECTION_ERROR_NONE;
497 EXPORT_API int connection_profile_refresh(connection_profile_h profile)
503 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
505 if (!(_connection_libnet_check_profile_validity(profile))) {
506 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
508 return CONNECTION_ERROR_INVALID_PARAMETER;
511 net_profile_info_t profile_info_local;
512 net_profile_info_t *profile_info = profile;
514 rv = net_get_profile_info(NULL, profile_info->ProfileName, &profile_info_local);
515 if (rv == NET_ERR_ACCESS_DENIED) {
516 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
517 CONN_UNLOCK; //LCOV_EXCL_LINE
518 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
519 } else if (rv != NET_ERR_NONE) {
520 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile information"); //LCOV_EXCL_LINE
521 CONN_UNLOCK; //LCOV_EXCL_LINE
522 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
525 memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
528 return CONNECTION_ERROR_NONE;
531 EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
535 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
537 if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
538 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
540 return CONNECTION_ERROR_INVALID_PARAMETER;
543 net_profile_info_t *profile_info = profile;
544 *state = _profile_convert_to_cp_state(profile_info->ProfileState);
547 return CONNECTION_ERROR_NONE;
550 EXPORT_API int connection_profile_get_internet_state(connection_profile_h profile,
551 connection_internet_state_e *state)
555 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
557 if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
558 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
560 return CONNECTION_ERROR_INVALID_PARAMETER;
563 net_profile_info_t *profile_info = profile;
564 if (profile_info->ProfileState == NET_STATE_TYPE_ONLINE)
565 *state = CONNECTION_INTERNET_STATE_ONLINE;
567 *state = CONNECTION_INTERNET_STATE_OFFLINE;
570 return CONNECTION_ERROR_NONE;
573 EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
574 connection_address_family_e address_family, connection_ip_config_type_e *type)
576 net_ip_config_type_t profile_type;
580 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
582 if (!(_connection_libnet_check_profile_validity(profile)) ||
583 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
584 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
586 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
588 return CONNECTION_ERROR_INVALID_PARAMETER;
591 net_profile_info_t *profile_info = profile;
592 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
593 if (net_info == NULL) {
594 CONN_UNLOCK; //LCOV_EXCL_LINE
595 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
598 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
599 profile_type = net_info->IpConfigType;
601 profile_type = net_info->IpConfigType6;
603 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
604 switch (profile_type) {
606 case NET_IP_CONFIG_TYPE_STATIC:
607 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
610 case NET_IP_CONFIG_TYPE_DYNAMIC:
611 *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
614 case NET_IP_CONFIG_TYPE_AUTO_IP:
615 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
618 case NET_IP_CONFIG_TYPE_FIXED:
619 *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
622 case NET_IP_CONFIG_TYPE_OFF:
623 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
627 return CONNECTION_ERROR_OPERATION_FAILED;
632 switch (profile_type) {
633 case NET_IP_CONFIG_TYPE_STATIC:
634 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
637 case NET_IP_CONFIG_TYPE_AUTO_IP:
638 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
641 case NET_IP_CONFIG_TYPE_OFF:
642 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
647 return CONNECTION_ERROR_OPERATION_FAILED;
654 return CONNECTION_ERROR_NONE;
657 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
658 connection_address_family_e address_family, char** ip_address)
662 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
664 if (!(_connection_libnet_check_profile_validity(profile)) ||
665 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
666 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
667 ip_address == NULL) {
668 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
670 return CONNECTION_ERROR_INVALID_PARAMETER;
673 net_profile_info_t *profile_info = profile;
674 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
675 if (net_info == NULL) {
676 CONN_UNLOCK; //LCOV_EXCL_LINE
677 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
680 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
681 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
684 if (net_get_preferred_ipv6_address(net_info->ProfileName, ip_address) != NET_ERR_NONE) {
685 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get preferred ipv6 address"); //LCOV_EXCL_LINE
686 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr6, //LCOV_EXCL_LINE
691 if (*ip_address == NULL) {
692 CONN_UNLOCK; //LCOV_EXCL_LINE
693 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
697 return CONNECTION_ERROR_NONE;
700 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
701 connection_address_family_e address_family, char** subnet_mask)
705 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
707 if (!(_connection_libnet_check_profile_validity(profile)) ||
708 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
709 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
710 subnet_mask == NULL) {
711 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
713 return CONNECTION_ERROR_INVALID_PARAMETER;
716 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
717 CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
718 "Please uses connection_profile_get_prefix_length()");
719 CONN_UNLOCK; //LCOV_EXCL_LINE
720 return CONNECTION_ERROR_NOT_SUPPORTED; //LCOV_EXCL_LINE
723 net_profile_info_t *profile_info = profile;
724 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
725 if (net_info == NULL) {
726 CONN_UNLOCK; //LCOV_EXCL_LINE
727 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
730 *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask,
733 if (*subnet_mask == NULL) {
734 CONN_UNLOCK; //LCOV_EXCL_LINE
735 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
739 return CONNECTION_ERROR_NONE;
742 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
743 connection_address_family_e address_family, char** gateway_address)
747 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
749 if (!(_connection_libnet_check_profile_validity(profile)) ||
750 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
751 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
752 gateway_address == NULL) {
753 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
755 return CONNECTION_ERROR_INVALID_PARAMETER;
758 net_profile_info_t *profile_info = profile;
759 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
760 if (net_info == NULL) {
761 CONN_UNLOCK; //LCOV_EXCL_LINE
762 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
765 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
766 *gateway_address = __profile_convert_ip_to_string(
767 &net_info->GatewayAddr6, address_family);
769 *gateway_address = __profile_convert_ip_to_string(
770 &net_info->GatewayAddr, address_family);
772 if (*gateway_address == NULL) {
773 CONN_UNLOCK; //LCOV_EXCL_LINE
774 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
778 return CONNECTION_ERROR_NONE;
781 EXPORT_API int connection_profile_get_dhcp_server_address(
782 connection_profile_h profile,
783 connection_address_family_e address_family, char** dhcp_server)
787 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
789 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
790 CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
792 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
795 if (!(_connection_libnet_check_profile_validity(profile)) ||
796 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4) ||
797 dhcp_server == NULL) {
798 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
800 return CONNECTION_ERROR_INVALID_PARAMETER;
803 net_profile_info_t *profile_info = profile;
804 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
805 if (net_info == NULL) {
806 CONN_UNLOCK; //LCOV_EXCL_LINE
807 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
810 CONNECTION_LOG(CONNECTION_INFO, "IP Config %d, DHCP Server Address %s",
811 net_info->IpConfigType, (net_info->BServerAddr ? "TRUE" : "FALSE"));
813 *dhcp_server = __profile_convert_ip_to_string(&net_info->ServerAddr,
816 if (*dhcp_server == NULL) {
817 CONN_UNLOCK; //LCOV_EXCL_LINE
818 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
822 return CONNECTION_ERROR_NONE;
825 EXPORT_API int connection_profile_get_dhcp_lease_duration(
826 connection_profile_h profile,
827 connection_address_family_e address_family, int* dhcp_lease_duration)
831 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
833 if (!(_connection_libnet_check_profile_validity(profile)) ||
834 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
835 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
836 dhcp_lease_duration == NULL) {
837 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
839 return CONNECTION_ERROR_INVALID_PARAMETER;
842 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
843 CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
845 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
848 net_profile_info_t *profile_info = profile;
849 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
850 if (net_info == NULL) {
851 CONN_UNLOCK; //LCOV_EXCL_LINE
852 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
855 CONNECTION_LOG(CONNECTION_INFO, "Lease duration : %d",
856 net_info->DHCPLeaseDuration);
858 *dhcp_lease_duration = net_info->DHCPLeaseDuration;
861 return CONNECTION_ERROR_NONE;
864 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
865 connection_address_family_e address_family, char** dns_address)
869 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
871 if (!(_connection_libnet_check_profile_validity(profile)) ||
872 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
873 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
874 dns_address == NULL ||
876 order > NET_DNS_ADDR_MAX) {
877 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
879 return CONNECTION_ERROR_INVALID_PARAMETER;
882 net_profile_info_t *profile_info = profile;
883 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
884 if (net_info == NULL) {
885 CONN_UNLOCK; //LCOV_EXCL_LINE
886 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
889 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
890 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
892 else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) //LCOV_EXCL_LINE
893 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1], //LCOV_EXCL_LINE
896 if (*dns_address == NULL) {
897 CONN_UNLOCK; //LCOV_EXCL_LINE
898 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
902 return CONNECTION_ERROR_NONE;
905 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e *type)
909 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
911 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
912 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
914 return CONNECTION_ERROR_INVALID_PARAMETER;
917 net_profile_info_t *profile_info = profile;
918 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
919 if (net_info == NULL) {
920 CONN_UNLOCK; //LCOV_EXCL_LINE
921 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
925 if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
926 char *proxy = __profile_get_ethernet_proxy();
928 *type = CONNECTION_PROXY_TYPE_DIRECT;
930 *type = CONNECTION_PROXY_TYPE_MANUAL;
935 return CONNECTION_ERROR_NONE;
939 switch (net_info->ProxyMethod) {
941 case NET_PROXY_TYPE_DIRECT:
942 *type = CONNECTION_PROXY_TYPE_DIRECT;
944 case NET_PROXY_TYPE_AUTO:
945 *type = CONNECTION_PROXY_TYPE_AUTO;
947 case NET_PROXY_TYPE_MANUAL:
948 *type = CONNECTION_PROXY_TYPE_MANUAL;
950 case NET_PROXY_TYPE_UNKNOWN:
953 return CONNECTION_ERROR_OPERATION_FAILED;
958 return CONNECTION_ERROR_NONE;
961 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
962 connection_address_family_e address_family, char** proxy_address)
966 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
968 if (!(_connection_libnet_check_profile_validity(profile)) ||
969 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
970 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
971 proxy_address == NULL) {
972 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
974 return CONNECTION_ERROR_INVALID_PARAMETER;
977 net_profile_info_t *profile_info = profile;
978 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
979 if (net_info == NULL) {
980 CONN_UNLOCK; //LCOV_EXCL_LINE
981 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
984 *proxy_address = g_strdup(net_info->ProxyAddr);
986 if (*proxy_address == NULL) {
987 CONN_UNLOCK; //LCOV_EXCL_LINE
988 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
992 return CONNECTION_ERROR_NONE;
995 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
996 connection_address_family_e address_family, connection_ip_config_type_e type)
998 net_ip_config_type_t *profile_type = NULL;
1002 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1004 if (!(_connection_libnet_check_profile_validity(profile)) ||
1005 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1006 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1007 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1009 return CONNECTION_ERROR_INVALID_PARAMETER;
1012 net_profile_info_t *profile_info = profile;
1013 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1014 if (net_info == NULL) {
1015 CONN_UNLOCK; //LCOV_EXCL_LINE
1016 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1019 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
1020 profile_type = &net_info->IpConfigType ;
1022 profile_type = &net_info->IpConfigType6 ;
1024 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1027 case CONNECTION_IP_CONFIG_TYPE_STATIC:
1028 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
1029 net_info->IpAddr.Data.Ipv4.s_addr = 0;
1030 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
1031 net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
1034 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
1035 *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
1038 case CONNECTION_IP_CONFIG_TYPE_AUTO:
1039 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
1042 case CONNECTION_IP_CONFIG_TYPE_FIXED:
1043 net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
1046 case CONNECTION_IP_CONFIG_TYPE_NONE:
1047 *profile_type = NET_IP_CONFIG_TYPE_OFF;
1052 return CONNECTION_ERROR_INVALID_PARAMETER;
1058 case CONNECTION_IP_CONFIG_TYPE_STATIC:
1059 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
1060 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
1061 net_info->PrefixLen6 = 0 ;
1062 inet_pton(AF_INET6, "::",
1063 &net_info->GatewayAddr6.Data.Ipv6);
1066 case CONNECTION_IP_CONFIG_TYPE_AUTO:
1067 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
1070 case CONNECTION_IP_CONFIG_TYPE_NONE:
1071 *profile_type = NET_IP_CONFIG_TYPE_OFF;
1076 return CONNECTION_ERROR_INVALID_PARAMETER;
1082 return CONNECTION_ERROR_NONE;
1085 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
1086 connection_address_family_e address_family, const char* ip_address)
1090 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1092 if (!(_connection_libnet_check_profile_validity(profile)) ||
1093 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1094 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1095 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1097 return CONNECTION_ERROR_INVALID_PARAMETER;
1100 net_profile_info_t *profile_info = profile;
1101 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1102 if (net_info == NULL) {
1103 CONN_UNLOCK; //LCOV_EXCL_LINE
1104 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1107 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1109 if (ip_address == NULL)
1110 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
1111 else if (inet_pton(AF_INET6, ip_address, &net_info->IpAddr6.Data.Ipv6) < 1) {
1113 return CONNECTION_ERROR_INVALID_PARAMETER;
1117 if (ip_address == NULL)
1118 net_info->IpAddr.Data.Ipv4.s_addr = 0;
1119 else if (inet_pton(AF_INET, ip_address, &net_info->IpAddr.Data.Ipv4) < 1) {
1120 CONN_UNLOCK; //LCOV_EXCL_LINE
1121 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1126 return CONNECTION_ERROR_NONE;
1129 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
1130 connection_address_family_e address_family, const char* subnet_mask)
1134 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1136 if (!(_connection_libnet_check_profile_validity(profile)) ||
1137 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1138 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1139 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1141 return CONNECTION_ERROR_INVALID_PARAMETER;
1144 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1145 CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
1146 "Please uses connection_profile_set_prefix_length()");
1147 CONN_UNLOCK; //LCOV_EXCL_LINE
1148 return CONNECTION_ERROR_NOT_SUPPORTED; //LCOV_EXCL_LINE
1151 net_profile_info_t *profile_info = profile;
1152 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1153 if (net_info == NULL) {
1154 CONN_UNLOCK; //LCOV_EXCL_LINE
1155 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1158 if (subnet_mask == NULL)
1159 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
1160 else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4) < 1) {
1161 CONN_UNLOCK; //LCOV_EXCL_LINE
1162 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1165 net_info->PrefixLen = __profile_convert_netmask_to_prefix_len(subnet_mask);
1166 if (net_info->PrefixLen <= 0 || net_info->PrefixLen > 31) {
1167 CONNECTION_LOG(CONNECTION_ERROR, "Invalid Prefix length: %d", net_info->PrefixLen); //LCOV_EXCL_LINE
1168 CONN_UNLOCK; //LCOV_EXCL_LINE
1169 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1173 return CONNECTION_ERROR_NONE;
1176 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
1177 connection_address_family_e address_family, const char* gateway_address)
1181 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1183 if (!(_connection_libnet_check_profile_validity(profile)) ||
1184 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1185 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1186 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1188 return CONNECTION_ERROR_INVALID_PARAMETER;
1191 net_profile_info_t *profile_info = profile;
1192 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1193 if (net_info == NULL) {
1194 CONN_UNLOCK; //LCOV_EXCL_LINE
1195 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1198 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1200 if (gateway_address == NULL)
1201 inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
1202 else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1) {
1204 return CONNECTION_ERROR_INVALID_PARAMETER;
1208 if (gateway_address == NULL)
1209 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
1210 else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1) {
1211 CONN_UNLOCK; //LCOV_EXCL_LINE
1212 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1217 return CONNECTION_ERROR_NONE;
1220 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
1221 connection_address_family_e address_family, const char* dns_address)
1225 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1227 if (!(_connection_libnet_check_profile_validity(profile)) ||
1228 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1229 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1231 order > NET_DNS_ADDR_MAX) {
1232 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1234 return CONNECTION_ERROR_INVALID_PARAMETER;
1237 net_profile_info_t *profile_info = profile;
1238 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1239 if (net_info == NULL) {
1240 CONN_UNLOCK; //LCOV_EXCL_LINE
1241 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1244 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1246 net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
1247 if (dns_address == NULL)
1248 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
1249 else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1) {
1251 return CONNECTION_ERROR_INVALID_PARAMETER;
1253 if (net_info->DnsCount6 < order)
1254 net_info->DnsCount6 = order;
1257 net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
1258 if (dns_address == NULL)
1259 net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
1260 else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1) {
1261 CONN_UNLOCK; //LCOV_EXCL_LINE
1262 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1264 if (net_info->DnsCount < order)
1265 net_info->DnsCount = order;
1269 return CONNECTION_ERROR_NONE;
1272 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
1276 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1278 if (!(_connection_libnet_check_profile_validity(profile))) {
1279 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1281 return CONNECTION_ERROR_INVALID_PARAMETER;
1284 net_profile_info_t *profile_info = profile;
1285 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1286 if (net_info == NULL) {
1287 CONN_UNLOCK; //LCOV_EXCL_LINE
1288 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1293 case CONNECTION_PROXY_TYPE_DIRECT:
1294 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
1296 case CONNECTION_PROXY_TYPE_AUTO:
1297 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
1299 case CONNECTION_PROXY_TYPE_MANUAL:
1300 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
1304 return CONNECTION_ERROR_INVALID_PARAMETER;
1309 return CONNECTION_ERROR_NONE;
1312 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
1313 connection_address_family_e address_family, const char* proxy_address)
1315 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1317 CONNECTION_LOG(CONNECTION_ERROR, "Address Family: %d", address_family);
1318 if (!(_connection_libnet_check_profile_validity(profile)) ||
1319 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1320 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1321 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1323 return CONNECTION_ERROR_INVALID_PARAMETER;
1326 net_profile_info_t *profile_info = profile;
1327 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1328 if (net_info == NULL) {
1329 CONN_UNLOCK; //LCOV_EXCL_LINE
1330 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1333 if (proxy_address == NULL)
1334 net_info->ProxyAddr[0] = '\0';
1336 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
1339 return CONNECTION_ERROR_NONE;
1342 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
1343 connection_profile_state_changed_cb callback, void* user_data)
1347 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1349 if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
1350 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1352 return CONNECTION_ERROR_INVALID_PARAMETER;
1355 if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data)) {
1357 return CONNECTION_ERROR_NONE;
1360 CONN_UNLOCK; //LCOV_EXCL_LINE
1361 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1364 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
1368 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1370 if (!(_connection_libnet_check_profile_validity(profile))) {
1371 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1373 return CONNECTION_ERROR_INVALID_PARAMETER;
1376 if (_connection_libnet_remove_from_profile_cb_list(profile) != true) {
1377 CONN_UNLOCK; //LCOV_EXCL_LINE
1378 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1382 return CONNECTION_ERROR_NONE;
1386 /* Wi-Fi profile *************************************************************/
1387 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
1391 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1393 if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
1394 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1396 return CONNECTION_ERROR_INVALID_PARAMETER;
1399 net_profile_info_t *profile_info = profile;
1401 if (profile_info->profile_type != NET_DEVICE_WIFI &&
1402 profile_info->profile_type != NET_DEVICE_MESH) {
1404 return CONNECTION_ERROR_INVALID_PARAMETER;
1407 if (profile_info->profile_type == NET_DEVICE_WIFI)
1408 *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
1410 *essid = g_strdup(profile_info->ProfileInfo.Mesh.essid);
1412 if (*essid == NULL) {
1413 CONN_UNLOCK; //LCOV_EXCL_LINE
1414 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1418 return CONNECTION_ERROR_NONE;
1421 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
1425 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1427 if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
1428 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1430 return CONNECTION_ERROR_INVALID_PARAMETER;
1433 net_profile_info_t *profile_info = profile;
1435 if (profile_info->profile_type != NET_DEVICE_WIFI &&
1436 profile_info->profile_type != NET_DEVICE_MESH) {
1438 return CONNECTION_ERROR_INVALID_PARAMETER;
1441 if (profile_info->profile_type == NET_DEVICE_WIFI)
1442 *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
1444 *bssid = g_strdup(profile_info->ProfileInfo.Mesh.bssid);
1446 if (*bssid == NULL) {
1447 CONN_UNLOCK; //LCOV_EXCL_LINE
1448 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1452 return CONNECTION_ERROR_NONE;
1455 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1459 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1461 if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
1462 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1464 return CONNECTION_ERROR_INVALID_PARAMETER;
1467 net_profile_info_t *profile_info = profile;
1469 if (profile_info->profile_type != NET_DEVICE_WIFI &&
1470 profile_info->profile_type != NET_DEVICE_MESH) {
1472 return CONNECTION_ERROR_INVALID_PARAMETER;
1475 if (profile_info->profile_type == NET_DEVICE_WIFI)
1476 *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1478 *rssi = (int)profile_info->ProfileInfo.Mesh.Strength;
1481 return CONNECTION_ERROR_NONE;
1484 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1488 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1490 if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
1491 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1493 return CONNECTION_ERROR_INVALID_PARAMETER;
1496 net_profile_info_t *profile_info = profile;
1498 if (profile_info->profile_type != NET_DEVICE_WIFI &&
1499 profile_info->profile_type != NET_DEVICE_MESH) {
1501 return CONNECTION_ERROR_INVALID_PARAMETER;
1504 if (profile_info->profile_type == NET_DEVICE_WIFI)
1505 *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1507 *frequency = (int)profile_info->ProfileInfo.Mesh.frequency;
1510 return CONNECTION_ERROR_NONE;
1513 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1517 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1519 if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
1520 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1522 return CONNECTION_ERROR_INVALID_PARAMETER;
1525 net_profile_info_t *profile_info = profile;
1527 if (profile_info->profile_type != NET_DEVICE_WIFI) {
1529 return CONNECTION_ERROR_INVALID_PARAMETER;
1532 *max_speed = profile_info->ProfileInfo.Wlan.max_rate;
1535 return CONNECTION_ERROR_NONE;
1538 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e *type)
1542 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1544 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1545 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1547 return CONNECTION_ERROR_INVALID_PARAMETER;
1550 net_profile_info_t *profile_info = profile;
1552 wlan_security_mode_type_t sec_mode;
1553 if (profile_info->profile_type != NET_DEVICE_WIFI &&
1554 profile_info->profile_type != NET_DEVICE_MESH) {
1556 return CONNECTION_ERROR_INVALID_PARAMETER;
1559 if (profile_info->profile_type == NET_DEVICE_WIFI)
1560 sec_mode = profile_info->ProfileInfo.Wlan.security_info.sec_mode;
1562 sec_mode = profile_info->ProfileInfo.Mesh.security_info.sec_mode;
1566 case WLAN_SEC_MODE_NONE:
1567 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1569 case WLAN_SEC_MODE_WEP:
1570 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1572 case WLAN_SEC_MODE_IEEE8021X:
1573 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1575 case WLAN_SEC_MODE_WPA_PSK:
1576 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1578 case WLAN_SEC_MODE_WPA2_PSK:
1579 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1581 case WLAN_SEC_MODE_SAE:
1582 *type = CONNECTION_WIFI_SECURITY_TYPE_SAE;
1586 return CONNECTION_ERROR_OPERATION_FAILED;
1591 return CONNECTION_ERROR_NONE;
1594 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e *type)
1598 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1600 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1601 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1603 return CONNECTION_ERROR_INVALID_PARAMETER;
1606 net_profile_info_t *profile_info = profile;
1608 if (profile_info->profile_type != NET_DEVICE_WIFI) {
1610 return CONNECTION_ERROR_INVALID_PARAMETER;
1613 switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1615 case WLAN_ENC_MODE_NONE:
1616 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1618 case WLAN_ENC_MODE_WEP:
1619 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1621 case WLAN_ENC_MODE_TKIP:
1622 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1624 case WLAN_ENC_MODE_AES:
1625 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1627 case WLAN_ENC_MODE_TKIP_AES_MIXED:
1628 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1632 return CONNECTION_ERROR_OPERATION_FAILED;
1637 return CONNECTION_ERROR_NONE;
1640 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1644 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1646 if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1647 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1649 return CONNECTION_ERROR_INVALID_PARAMETER;
1652 net_profile_info_t *profile_info = profile;
1654 wlan_security_mode_type_t sec_mode;
1655 if (profile_info->profile_type != NET_DEVICE_WIFI &&
1656 profile_info->profile_type != NET_DEVICE_MESH) {
1658 return CONNECTION_ERROR_INVALID_PARAMETER;
1661 if (profile_info->Favourite) {
1662 *required = false; //LCOV_EXCL_LINE
1663 CONN_UNLOCK; //LCOV_EXCL_LINE
1664 return CONNECTION_ERROR_NONE; //LCOV_EXCL_LINE
1667 if (profile_info->profile_type == NET_DEVICE_WIFI)
1668 sec_mode = profile_info->ProfileInfo.Wlan.security_info.sec_mode;
1670 sec_mode = profile_info->ProfileInfo.Mesh.security_info.sec_mode;
1674 case WLAN_SEC_MODE_NONE:
1677 case WLAN_SEC_MODE_WEP:
1678 case WLAN_SEC_MODE_IEEE8021X:
1679 case WLAN_SEC_MODE_WPA_PSK:
1680 case WLAN_SEC_MODE_WPA2_PSK:
1681 case WLAN_SEC_MODE_SAE:
1686 return CONNECTION_ERROR_OPERATION_FAILED;
1691 return CONNECTION_ERROR_NONE;
1694 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1698 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1700 if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1701 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1703 return CONNECTION_ERROR_INVALID_PARAMETER;
1706 net_profile_info_t *profile_info = profile;
1708 if (profile_info->profile_type != NET_DEVICE_WIFI &&
1709 profile_info->profile_type != NET_DEVICE_MESH) {
1711 return CONNECTION_ERROR_INVALID_PARAMETER;
1714 if (profile_info->profile_type == NET_DEVICE_WIFI)
1715 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1716 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1718 g_strlcpy(profile_info->ProfileInfo.Mesh.security_info.authentication.sae.saeKey,
1719 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1722 return CONNECTION_ERROR_NONE;
1725 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1729 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1731 if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1732 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1734 return CONNECTION_ERROR_INVALID_PARAMETER;
1737 net_profile_info_t *profile_info = profile;
1739 if (profile_info->profile_type != NET_DEVICE_WIFI) {
1741 return CONNECTION_ERROR_INVALID_PARAMETER;
1744 if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1750 return CONNECTION_ERROR_NONE;
1754 /* Cellular profile **********************************************************/
1755 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1756 connection_cellular_service_type_e* type)
1760 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1762 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1763 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1765 return CONNECTION_ERROR_INVALID_PARAMETER;
1768 net_profile_info_t *profile_info = profile;
1770 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1771 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1773 return CONNECTION_ERROR_INVALID_PARAMETER;
1776 *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1778 if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1779 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed"); //LCOV_EXCL_LINE
1780 CONN_UNLOCK; //LCOV_EXCL_LINE
1781 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1785 return CONNECTION_ERROR_NONE;
1788 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1792 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1794 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1795 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1797 return CONNECTION_ERROR_INVALID_PARAMETER;
1800 net_profile_info_t *profile_info = profile;
1802 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1803 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1804 CONN_UNLOCK; //LCOV_EXCL_LINE
1805 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1808 *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1810 CONN_UNLOCK; //LCOV_EXCL_LINE
1811 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1815 return CONNECTION_ERROR_NONE;
1818 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1819 connection_cellular_auth_type_e *type, char** user_name, char** password)
1823 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1825 if (!(_connection_libnet_check_profile_validity(profile)) ||
1826 type == NULL || user_name == NULL || password == NULL) {
1827 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1829 return CONNECTION_ERROR_INVALID_PARAMETER;
1832 net_profile_info_t *profile_info = profile;
1834 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1835 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1837 return CONNECTION_ERROR_INVALID_PARAMETER;
1840 switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1842 case NET_PDP_AUTH_NONE:
1843 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1845 case NET_PDP_AUTH_PAP:
1846 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1848 case NET_PDP_AUTH_CHAP:
1849 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1853 return CONNECTION_ERROR_OPERATION_FAILED;
1857 *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1858 if (*user_name == NULL) {
1859 CONN_UNLOCK; //LCOV_EXCL_LINE
1860 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1863 *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1864 if (*password == NULL) {
1865 g_free(*user_name); //LCOV_EXCL_LINE
1866 CONN_UNLOCK; //LCOV_EXCL_LINE
1867 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1871 return CONNECTION_ERROR_NONE;
1874 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1878 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1880 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1881 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1883 return CONNECTION_ERROR_INVALID_PARAMETER;
1886 net_profile_info_t *profile_info = profile;
1888 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1889 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1891 return CONNECTION_ERROR_INVALID_PARAMETER;
1894 *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1895 if (*home_url == NULL) {
1896 CONN_UNLOCK; //LCOV_EXCL_LINE
1897 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1901 return CONNECTION_ERROR_NONE;
1904 EXPORT_API int connection_profile_get_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1908 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1910 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1911 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1913 return CONNECTION_ERROR_INVALID_PARAMETER;
1916 net_profile_info_t *profile_info = profile;
1918 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1919 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1921 return CONNECTION_ERROR_INVALID_PARAMETER;
1924 switch (profile_info->ProfileInfo.Pdp.PdnType) {
1926 case NET_PDN_TYPE_UNKNOWN:
1927 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1929 case NET_PDN_TYPE_IPV4:
1930 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1932 case NET_PDN_TYPE_IPV6:
1933 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1935 case NET_PDN_TYPE_IPV4_IPV6:
1936 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1940 return CONNECTION_ERROR_OPERATION_FAILED;
1945 return CONNECTION_ERROR_NONE;
1948 EXPORT_API int connection_profile_get_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1952 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1954 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1955 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1957 return CONNECTION_ERROR_INVALID_PARAMETER;
1960 net_profile_info_t *profile_info = profile;
1962 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1963 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1965 return CONNECTION_ERROR_INVALID_PARAMETER;
1968 switch (profile_info->ProfileInfo.Pdp.RoamPdnType) {
1970 case NET_PDN_TYPE_UNKNOWN:
1971 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1973 case NET_PDN_TYPE_IPV4:
1974 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1976 case NET_PDN_TYPE_IPV6:
1977 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1979 case NET_PDN_TYPE_IPV4_IPV6:
1980 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1984 return CONNECTION_ERROR_OPERATION_FAILED;
1989 return CONNECTION_ERROR_NONE;
1992 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1996 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1998 if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1999 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2001 return CONNECTION_ERROR_INVALID_PARAMETER;
2004 net_profile_info_t *profile_info = profile;
2006 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2007 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2009 return CONNECTION_ERROR_INVALID_PARAMETER;
2012 if (profile_info->ProfileInfo.Pdp.Roaming)
2015 *is_roaming = false;
2018 return CONNECTION_ERROR_NONE;
2021 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
2025 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2027 if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
2028 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2030 return CONNECTION_ERROR_INVALID_PARAMETER;
2033 net_profile_info_t *profile_info = profile;
2035 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2036 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2038 return CONNECTION_ERROR_INVALID_PARAMETER;
2041 if (profile_info->ProfileInfo.Pdp.Hidden)
2047 return CONNECTION_ERROR_NONE;
2050 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
2054 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2056 if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
2057 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2059 return CONNECTION_ERROR_INVALID_PARAMETER;
2062 net_profile_info_t *profile_info = profile;
2064 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2065 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2067 return CONNECTION_ERROR_INVALID_PARAMETER;
2070 if (profile_info->ProfileInfo.Pdp.Editable)
2071 *is_editable = true;
2073 *is_editable = false;
2076 return CONNECTION_ERROR_NONE;
2079 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
2083 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2085 if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
2086 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2088 return CONNECTION_ERROR_INVALID_PARAMETER;
2091 net_profile_info_t *profile_info = profile;
2093 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2094 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2096 return CONNECTION_ERROR_INVALID_PARAMETER;
2099 if (profile_info->ProfileInfo.Pdp.DefaultConn)
2102 *is_default = false;
2105 return CONNECTION_ERROR_NONE;
2108 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
2109 connection_cellular_service_type_e service_type)
2113 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2115 if (!(_connection_libnet_check_profile_validity(profile))) {
2116 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2118 return CONNECTION_ERROR_INVALID_PARAMETER;
2121 net_profile_info_t *profile_info = profile;
2123 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2124 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2126 return CONNECTION_ERROR_INVALID_PARAMETER;
2129 switch (service_type) {
2131 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
2132 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
2134 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
2135 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
2137 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
2138 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
2140 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
2141 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
2143 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
2144 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
2146 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
2147 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
2149 case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
2152 return CONNECTION_ERROR_INVALID_PARAMETER;
2157 return CONNECTION_ERROR_NONE;
2160 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
2164 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2166 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
2167 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2169 return CONNECTION_ERROR_INVALID_PARAMETER;
2172 net_profile_info_t *profile_info = profile;
2174 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2175 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2177 return CONNECTION_ERROR_INVALID_PARAMETER;
2180 g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
2183 return CONNECTION_ERROR_NONE;
2186 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
2187 connection_cellular_auth_type_e type, const char* user_name, const char* password)
2191 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2193 if (!(_connection_libnet_check_profile_validity(profile)) ||
2194 user_name == NULL || password == NULL) {
2195 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2197 return CONNECTION_ERROR_INVALID_PARAMETER;
2200 net_profile_info_t *profile_info = profile;
2202 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2203 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2205 return CONNECTION_ERROR_INVALID_PARAMETER;
2210 case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
2211 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
2213 case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
2214 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
2216 case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
2217 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
2221 return CONNECTION_ERROR_INVALID_PARAMETER;
2225 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
2226 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
2229 return CONNECTION_ERROR_NONE;
2232 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
2236 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2238 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
2239 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2241 return CONNECTION_ERROR_INVALID_PARAMETER;
2244 net_profile_info_t *profile_info = profile;
2246 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2247 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2249 return CONNECTION_ERROR_INVALID_PARAMETER;
2252 g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
2255 return CONNECTION_ERROR_NONE;
2258 EXPORT_API int connection_profile_set_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
2262 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2264 if (!(_connection_libnet_check_profile_validity(profile))) {
2265 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2267 return CONNECTION_ERROR_INVALID_PARAMETER;
2270 net_profile_info_t *profile_info = profile;
2272 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2273 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2275 return CONNECTION_ERROR_INVALID_PARAMETER;
2280 case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
2281 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4;
2283 case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
2284 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV6;
2286 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
2287 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
2288 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
2289 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
2291 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
2292 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
2296 return CONNECTION_ERROR_INVALID_PARAMETER;
2301 return CONNECTION_ERROR_NONE;
2304 EXPORT_API int connection_profile_set_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
2308 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2310 if (!(_connection_libnet_check_profile_validity(profile))) {
2311 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2313 return CONNECTION_ERROR_INVALID_PARAMETER;
2316 net_profile_info_t *profile_info = profile;
2318 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2319 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2321 return CONNECTION_ERROR_INVALID_PARAMETER;
2326 case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
2327 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4;
2329 case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
2330 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV6;
2332 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
2333 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
2334 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
2335 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
2337 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
2338 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
2342 return CONNECTION_ERROR_INVALID_PARAMETER;
2347 return CONNECTION_ERROR_NONE;
2350 EXPORT_API int connection_profile_get_ipv6_state(connection_profile_h profile, connection_profile_state_e *state)
2354 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2355 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2357 if (!(_connection_libnet_check_profile_validity(profile)) ||
2359 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2361 return CONNECTION_ERROR_INVALID_PARAMETER;
2364 net_profile_info_t *profile_info = profile;
2365 *state = _profile_convert_to_cp_state(profile_info->ProfileState6);
2368 return CONNECTION_ERROR_NONE;
2371 EXPORT_API int connection_profile_set_dns_config_type(connection_profile_h profile,
2372 connection_address_family_e address_family, connection_dns_config_type_e type)
2376 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2377 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2379 if (!(_connection_libnet_check_profile_validity(profile))) {
2380 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2382 return CONNECTION_ERROR_INVALID_PARAMETER;
2385 if ((address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2386 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2387 (type != CONNECTION_DNS_CONFIG_TYPE_STATIC &&
2388 type != CONNECTION_DNS_CONFIG_TYPE_DYNAMIC)) {
2389 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2390 CONN_UNLOCK; //LCOV_EXCL_LINE
2391 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2394 net_dns_config_type_t *profileType = NULL;
2395 net_dns_config_type_t *profileType6 = NULL;
2396 net_profile_info_t *profile_info = profile;
2398 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2399 if (net_info == NULL) {
2400 CONN_UNLOCK; //LCOV_EXCL_LINE
2401 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
2404 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
2405 profileType = &net_info->DnsConfigType;
2406 net_info->DnsAddr[0].Data.Ipv4.s_addr = 0;
2407 net_info->DnsAddr[1].Data.Ipv4.s_addr = 0;
2408 *profileType = type;
2410 profileType6 = &net_info->DnsConfigType6;
2411 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[0].Data.Ipv6);
2412 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[1].Data.Ipv6);
2413 *profileType6 = type;
2417 return CONNECTION_ERROR_NONE;
2420 EXPORT_API int connection_profile_get_dns_config_type(connection_profile_h profile,
2421 connection_address_family_e address_family, connection_dns_config_type_e *type)
2425 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2426 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2428 if (!(_connection_libnet_check_profile_validity(profile)) ||
2429 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2430 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2432 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2434 return CONNECTION_ERROR_INVALID_PARAMETER;
2437 net_dns_config_type_t profileType;
2438 net_profile_info_t *profile_info = profile;
2439 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2440 if (net_info == NULL) {
2441 CONN_UNLOCK; //LCOV_EXCL_LINE
2442 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
2445 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
2446 profileType = net_info->DnsConfigType;
2448 profileType = net_info->DnsConfigType6;
2450 switch (profileType) {
2451 case NET_DNS_CONFIG_TYPE_STATIC:
2452 *type = CONNECTION_DNS_CONFIG_TYPE_STATIC;
2454 case NET_DNS_CONFIG_TYPE_DYNAMIC:
2455 *type = CONNECTION_DNS_CONFIG_TYPE_DYNAMIC;
2458 *type = CONNECTION_DNS_CONFIG_TYPE_NONE;
2463 return CONNECTION_ERROR_NONE;
2466 EXPORT_API int connection_profile_set_prefix_length(connection_profile_h profile,
2467 connection_address_family_e address_family, int prefix_len)
2471 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2472 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2474 if (!(_connection_libnet_check_profile_validity(profile)) ||
2475 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2476 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
2477 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2479 return CONNECTION_ERROR_INVALID_PARAMETER;
2482 net_profile_info_t *profile_info = profile;
2483 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2484 if (net_info == NULL) {
2485 CONN_UNLOCK; //LCOV_EXCL_LINE
2486 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
2489 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
2490 net_info->PrefixLen = prefix_len;
2491 net_info->SubnetMask.Data.Ipv4.s_addr = __profile_convert_prefix_len_to_netmask(prefix_len);
2493 net_info->PrefixLen6 = prefix_len;
2496 return CONNECTION_ERROR_NONE;
2499 EXPORT_API int connection_profile_get_prefix_length(connection_profile_h profile,
2500 connection_address_family_e address_family, int *prefix_len)
2504 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2505 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2507 if (!(_connection_libnet_check_profile_validity(profile)) ||
2508 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2509 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2510 prefix_len == NULL) {
2511 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2513 return CONNECTION_ERROR_INVALID_PARAMETER;
2516 net_profile_info_t *profile_info = profile;
2517 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2518 if (net_info == NULL) {
2519 CONN_UNLOCK; //LCOV_EXCL_LINE
2520 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
2523 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
2524 *prefix_len = net_info->PrefixLen;
2525 else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
2526 *prefix_len = net_info->PrefixLen6;
2529 return CONNECTION_ERROR_NONE;