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"
26 #define HTTP_PROXY "http_proxy"
27 #define MAX_PREFIX_LENGTH 6
29 static net_dev_info_t* __profile_get_net_info(net_profile_info_t *profile_info)
31 switch (profile_info->profile_type) {
32 case NET_DEVICE_CELLULAR:
33 return &profile_info->ProfileInfo.Pdp.net_info;
35 return &profile_info->ProfileInfo.Wlan.net_info;
36 case NET_DEVICE_ETHERNET:
37 return &profile_info->ProfileInfo.Ethernet.net_info; //LCOV_EXCL_LINE
38 case NET_DEVICE_BLUETOOTH:
39 return &profile_info->ProfileInfo.Bluetooth.net_info;
40 case NET_DEVICE_DEFAULT:
42 case NET_DEVICE_UNKNOWN:
49 static char *__profile_convert_ip_to_string(net_addr_t *ip_addr, connection_address_family_e address_family)
51 unsigned char *ipaddr = NULL;
54 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
55 ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
56 ipstr = g_try_malloc0(INET_ADDRSTRLEN);
60 inet_ntop(AF_INET, ipaddr, ipstr, INET_ADDRSTRLEN);
63 ipaddr = (unsigned char *)&ip_addr->Data.Ipv6.s6_addr;
64 ipstr = g_try_malloc0(INET6_ADDRSTRLEN);
68 inet_ntop(AF_INET6, ipaddr, ipstr, INET6_ADDRSTRLEN);
75 static void __profile_init_cellular_profile(net_profile_info_t *profile_info, const char *keyword)
77 int default_subscriber_id = 0;
78 connection_profile_h profile = NULL;
80 profile_info->profile_type = NET_DEVICE_CELLULAR;
81 profile_info->ProfileState = NET_STATE_TYPE_IDLE;
82 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_UNKNOWN;
83 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_UNKNOWN;
84 profile_info->ProfileInfo.Pdp.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
85 profile_info->ProfileInfo.Pdp.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
86 g_strlcpy(profile_info->ProfileInfo.Pdp.Keyword, keyword, NET_PDP_APN_LEN_MAX);
88 if (vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE,
89 &default_subscriber_id) != 0)
90 CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
91 "Failed to get VCONF_TELEPHONY_DEFAULT_DATA_SERVICE");
93 profile = (connection_profile_h)profile_info;
94 _connection_libnet_set_cellular_subscriber_id(profile, default_subscriber_id);
97 static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
99 profile_info->profile_type = NET_DEVICE_WIFI;
100 profile_info->ProfileState = NET_STATE_TYPE_IDLE;
101 profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
102 profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
103 profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
104 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
105 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
109 static char* __profile_get_ethernet_proxy(void)
113 proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
116 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
124 static unsigned char __profile_convert_netmask_to_prefix_len(const char *netmask)
129 in_addr_t mask = inet_network(netmask);
130 in_addr_t host = ~mask;
131 unsigned char prefix_len = 0;
133 /* a valid netmask must be 2^n - 1 */
134 if ((host & (host + 1)) != 0)
137 for (; mask; mask <<= 1)
143 static in_addr_t __profile_convert_prefix_len_to_netmask(int prefix_len)
145 return (prefix_len ? (in_addr_t) 0xFFFFFFFFu >> (32 - prefix_len) : 0);
149 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
152 case NET_SERVICE_INTERNET:
153 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
154 case NET_SERVICE_MMS:
155 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
156 case NET_SERVICE_PREPAID_INTERNET:
157 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
158 case NET_SERVICE_PREPAID_MMS:
159 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
160 case NET_SERVICE_TETHERING:
161 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
162 case NET_SERVICE_APPLICATION:
163 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
165 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
169 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
171 connection_profile_state_e cp_state;
174 case NET_STATE_TYPE_ONLINE:
175 case NET_STATE_TYPE_READY:
176 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
178 case NET_STATE_TYPE_IDLE:
179 case NET_STATE_TYPE_FAILURE:
180 case NET_STATE_TYPE_DISCONNECT:
181 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
183 case NET_STATE_TYPE_ASSOCIATION:
184 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
186 case NET_STATE_TYPE_CONFIGURATION:
187 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
196 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
199 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
200 return NET_SERVICE_INTERNET;
201 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
202 return NET_SERVICE_MMS;
203 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
204 return NET_SERVICE_PREPAID_INTERNET;
205 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
206 return NET_SERVICE_PREPAID_MMS;
207 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
208 return NET_SERVICE_TETHERING;
209 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
210 return NET_SERVICE_APPLICATION;
212 return NET_SERVICE_UNKNOWN;
216 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
218 net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
221 case CONNECTION_PROFILE_STATE_CONNECTED:
222 libnet_state = NET_STATE_TYPE_ONLINE;
224 case CONNECTION_PROFILE_STATE_DISCONNECTED:
225 libnet_state = NET_STATE_TYPE_IDLE;
227 case CONNECTION_PROFILE_STATE_ASSOCIATION:
228 libnet_state = NET_STATE_TYPE_ASSOCIATION;
230 case CONNECTION_PROFILE_STATE_CONFIGURATION:
231 libnet_state = NET_STATE_TYPE_CONFIGURATION;
239 /* Connection profile ********************************************************/
240 EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
242 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
244 if (type == CONNECTION_PROFILE_TYPE_CELLULAR)
245 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
246 else if (type == CONNECTION_PROFILE_TYPE_WIFI)
247 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
249 if (type != CONNECTION_PROFILE_TYPE_CELLULAR &&
250 type != CONNECTION_PROFILE_TYPE_WIFI) {
251 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
252 return CONNECTION_ERROR_INVALID_PARAMETER;
255 if (profile == NULL) {
256 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
257 return CONNECTION_ERROR_INVALID_PARAMETER;
260 int rv = _connection_libnet_check_profile_privilege();
261 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
263 else if (rv != CONNECTION_ERROR_NONE) {
264 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create profile"); //LCOV_EXCL_LINE
265 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
268 net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
269 if (profile_info == NULL)
270 return CONNECTION_ERROR_OUT_OF_MEMORY;
272 if (type == CONNECTION_PROFILE_TYPE_CELLULAR) {
273 if (keyword == NULL) {
274 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
275 g_free(profile_info);
276 return CONNECTION_ERROR_INVALID_PARAMETER;
278 __profile_init_cellular_profile(profile_info, keyword);
279 } else if (type == CONNECTION_PROFILE_TYPE_WIFI) {
280 __profile_init_wifi_profile(profile_info);
283 *profile = (connection_profile_h)profile_info;
284 _connection_libnet_add_to_profile_list(*profile);
286 return CONNECTION_ERROR_NONE;
289 EXPORT_API int connection_profile_destroy(connection_profile_h profile)
291 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
293 if (!(_connection_libnet_check_profile_validity(profile))) {
294 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
295 return CONNECTION_ERROR_INVALID_PARAMETER;
298 _connection_libnet_remove_from_profile_list(profile);
300 return CONNECTION_ERROR_NONE;
303 EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
305 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
307 if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
308 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
309 return CONNECTION_ERROR_INVALID_PARAMETER;
312 *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
313 if (*cloned_profile == NULL)
314 return CONNECTION_ERROR_OUT_OF_MEMORY;
316 memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
317 _connection_libnet_add_to_profile_list(*cloned_profile);
319 return CONNECTION_ERROR_NONE;
322 EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
324 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
326 if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
327 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
328 return CONNECTION_ERROR_INVALID_PARAMETER;
331 net_profile_info_t *profile_info = profile;
333 char *prof_id = strrchr(profile_info->ProfileName, '/');
335 return CONNECTION_ERROR_INVALID_PARAMETER;
338 *profile_id = g_strdup(prof_id);
340 if (*profile_id == NULL)
341 return CONNECTION_ERROR_OUT_OF_MEMORY;
343 return CONNECTION_ERROR_NONE;
346 EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
348 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
350 if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
351 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
352 return CONNECTION_ERROR_INVALID_PARAMETER;
355 net_profile_info_t *profile_info = profile;
357 switch (profile_info->profile_type) {
358 case NET_DEVICE_CELLULAR:
359 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
361 case NET_DEVICE_WIFI:
362 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
364 case NET_DEVICE_ETHERNET:
365 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName); //LCOV_EXCL_LINE
366 break; //LCOV_EXCL_LINE
367 case NET_DEVICE_BLUETOOTH: {
368 char *bt_name = strrchr(profile_info->ProfileName, '/');
370 return CONNECTION_ERROR_INVALID_PARAMETER;
373 *profile_name = g_strdup(bt_name);
376 return CONNECTION_ERROR_INVALID_PARAMETER;
379 if (*profile_name == NULL)
380 return CONNECTION_ERROR_OUT_OF_MEMORY;
382 return CONNECTION_ERROR_NONE;
385 EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e *type)
387 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
389 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
390 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
391 return CONNECTION_ERROR_INVALID_PARAMETER;
394 net_profile_info_t *profile_info = profile;
396 switch (profile_info->profile_type) {
397 case NET_DEVICE_CELLULAR:
398 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
400 case NET_DEVICE_WIFI:
401 *type = CONNECTION_PROFILE_TYPE_WIFI;
403 case NET_DEVICE_ETHERNET:
404 *type = CONNECTION_PROFILE_TYPE_ETHERNET; //LCOV_EXCL_LINE
405 break; //LCOV_EXCL_LINE
406 case NET_DEVICE_BLUETOOTH:
407 *type = CONNECTION_PROFILE_TYPE_BT;
410 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type");
411 return CONNECTION_ERROR_OPERATION_FAILED;
414 return CONNECTION_ERROR_NONE;
417 EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
419 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
421 if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
422 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
423 return CONNECTION_ERROR_INVALID_PARAMETER;
426 net_profile_info_t *profile_info = profile;
427 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
428 if (net_info == NULL)
429 return CONNECTION_ERROR_INVALID_PARAMETER;
431 *interface_name = g_strdup(net_info->DevName);
432 if (*interface_name == NULL)
433 return CONNECTION_ERROR_OUT_OF_MEMORY;
435 return CONNECTION_ERROR_NONE;
438 EXPORT_API int connection_profile_refresh(connection_profile_h profile)
442 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
444 if (!(_connection_libnet_check_profile_validity(profile))) {
445 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
446 return CONNECTION_ERROR_INVALID_PARAMETER;
449 net_profile_info_t profile_info_local;
450 net_profile_info_t *profile_info = profile;
452 rv = net_get_profile_info(profile_info->ProfileName, &profile_info_local);
453 if (rv == NET_ERR_ACCESS_DENIED) {
454 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
455 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
456 } else if (rv != NET_ERR_NONE) {
457 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile information"); //LCOV_EXCL_LINE
458 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
461 memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
463 return CONNECTION_ERROR_NONE;
466 EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
468 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
470 if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
471 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
472 return CONNECTION_ERROR_INVALID_PARAMETER;
475 net_profile_info_t *profile_info = profile;
476 *state = _profile_convert_to_cp_state(profile_info->ProfileState);
478 return CONNECTION_ERROR_NONE;
481 EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
482 connection_address_family_e address_family, connection_ip_config_type_e *type)
484 net_ip_config_type_t profile_type;
486 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
488 if (!(_connection_libnet_check_profile_validity(profile)) ||
489 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
490 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
492 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
493 return CONNECTION_ERROR_INVALID_PARAMETER;
496 net_profile_info_t *profile_info = profile;
497 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
498 if (net_info == NULL)
499 return CONNECTION_ERROR_OPERATION_FAILED;
501 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
502 profile_type = net_info->IpConfigType;
504 profile_type = net_info->IpConfigType6;
506 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
507 switch (profile_type) {
509 case NET_IP_CONFIG_TYPE_STATIC:
510 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
513 case NET_IP_CONFIG_TYPE_DYNAMIC:
514 *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
517 case NET_IP_CONFIG_TYPE_AUTO_IP:
518 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
521 case NET_IP_CONFIG_TYPE_FIXED:
522 *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
525 case NET_IP_CONFIG_TYPE_OFF:
526 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
529 return CONNECTION_ERROR_OPERATION_FAILED;
534 switch (profile_type) {
535 case NET_IP_CONFIG_TYPE_STATIC:
536 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
539 case NET_IP_CONFIG_TYPE_AUTO_IP:
540 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
543 case NET_IP_CONFIG_TYPE_OFF:
544 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
548 return CONNECTION_ERROR_OPERATION_FAILED;
554 return CONNECTION_ERROR_NONE;
557 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
558 connection_address_family_e address_family, char** ip_address)
560 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
562 if (!(_connection_libnet_check_profile_validity(profile)) ||
563 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
564 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
565 ip_address == NULL) {
566 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
567 return CONNECTION_ERROR_INVALID_PARAMETER;
570 net_profile_info_t *profile_info = profile;
571 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
572 if (net_info == NULL)
573 return CONNECTION_ERROR_OPERATION_FAILED;
575 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
576 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
579 if (net_get_preferred_ipv6_address(net_info->ProfileName, ip_address) != NET_ERR_NONE) {
580 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get preferred ipv6 address");
581 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr6,
586 if (*ip_address == NULL)
587 return CONNECTION_ERROR_OUT_OF_MEMORY;
589 return CONNECTION_ERROR_NONE;
592 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
593 connection_address_family_e address_family, char** subnet_mask)
595 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
597 if (!(_connection_libnet_check_profile_validity(profile)) ||
598 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
599 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
600 subnet_mask == NULL) {
601 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
602 return CONNECTION_ERROR_INVALID_PARAMETER;
605 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
606 CONNECTION_LOG(CONNECTION_ERROR,
607 "Please uses connection_profile_get_prefix_length()");
608 return CONNECTION_ERROR_NOT_SUPPORTED;
611 net_profile_info_t *profile_info = profile;
612 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
613 if (net_info == NULL)
614 return CONNECTION_ERROR_OPERATION_FAILED;
616 *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask,
619 if (*subnet_mask == NULL)
620 return CONNECTION_ERROR_OUT_OF_MEMORY;
622 return CONNECTION_ERROR_NONE;
625 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
626 connection_address_family_e address_family, char** gateway_address)
628 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
630 if (!(_connection_libnet_check_profile_validity(profile)) ||
631 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
632 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
633 gateway_address == NULL) {
634 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
635 return CONNECTION_ERROR_INVALID_PARAMETER;
638 net_profile_info_t *profile_info = profile;
639 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
640 if (net_info == NULL)
641 return CONNECTION_ERROR_OPERATION_FAILED;
643 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
644 *gateway_address = __profile_convert_ip_to_string(
645 &net_info->GatewayAddr6, address_family);
647 *gateway_address = __profile_convert_ip_to_string(
648 &net_info->GatewayAddr, address_family);
650 if (*gateway_address == NULL)
651 return CONNECTION_ERROR_OUT_OF_MEMORY;
653 return CONNECTION_ERROR_NONE;
656 EXPORT_API int connection_profile_get_dhcp_server_address(
657 connection_profile_h profile,
658 connection_address_family_e address_family, char** dhcp_server)
660 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
662 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
663 CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
664 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
667 if (!(_connection_libnet_check_profile_validity(profile)) ||
668 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4) ||
669 dhcp_server == NULL) {
670 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
671 return CONNECTION_ERROR_INVALID_PARAMETER;
674 net_profile_info_t *profile_info = profile;
675 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
676 if (net_info == NULL)
677 return CONNECTION_ERROR_OPERATION_FAILED;
679 CONNECTION_LOG(CONNECTION_INFO, "IP Config %d, DHCP Server Address %s",
680 net_info->IpConfigType, (net_info->BServerAddr ? "TRUE" : "FALSE"));
682 *dhcp_server = __profile_convert_ip_to_string(&net_info->ServerAddr,
685 if (*dhcp_server == NULL)
686 return CONNECTION_ERROR_OUT_OF_MEMORY;
688 return CONNECTION_ERROR_NONE;
691 EXPORT_API int connection_profile_get_dhcp_lease_duration(
692 connection_profile_h profile,
693 connection_address_family_e address_family, int* dhcp_lease_duration)
695 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
697 if (!(_connection_libnet_check_profile_validity(profile)) ||
698 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
699 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
700 dhcp_lease_duration == NULL) {
701 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
702 return CONNECTION_ERROR_INVALID_PARAMETER;
705 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
706 CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
707 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
710 net_profile_info_t *profile_info = profile;
711 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
712 if (net_info == NULL)
713 return CONNECTION_ERROR_OPERATION_FAILED;
715 CONNECTION_LOG(CONNECTION_INFO, "Lease duration : %d",
716 net_info->DHCPLeaseDuration);
718 *dhcp_lease_duration = net_info->DHCPLeaseDuration;
720 return CONNECTION_ERROR_NONE;
723 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
724 connection_address_family_e address_family, char** dns_address)
726 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
728 if (!(_connection_libnet_check_profile_validity(profile)) ||
729 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
730 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
731 dns_address == NULL ||
733 order > NET_DNS_ADDR_MAX) {
734 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
735 return CONNECTION_ERROR_INVALID_PARAMETER;
738 net_profile_info_t *profile_info = profile;
739 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
740 if (net_info == NULL)
741 return CONNECTION_ERROR_OPERATION_FAILED;
743 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
744 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
746 else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) //LCOV_EXCL_LINE
747 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1], //LCOV_EXCL_LINE
750 if (*dns_address == NULL)
751 return CONNECTION_ERROR_OUT_OF_MEMORY;
753 return CONNECTION_ERROR_NONE;
756 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e *type)
758 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
760 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
761 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
762 return CONNECTION_ERROR_INVALID_PARAMETER;
765 net_profile_info_t *profile_info = profile;
766 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
767 if (net_info == NULL)
768 return CONNECTION_ERROR_OPERATION_FAILED;
771 if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
772 char *proxy = __profile_get_ethernet_proxy();
774 *type = CONNECTION_PROXY_TYPE_DIRECT;
776 *type = CONNECTION_PROXY_TYPE_MANUAL;
780 return CONNECTION_ERROR_NONE;
784 switch (net_info->ProxyMethod) {
786 case NET_PROXY_TYPE_DIRECT:
787 *type = CONNECTION_PROXY_TYPE_DIRECT;
789 case NET_PROXY_TYPE_AUTO:
790 *type = CONNECTION_PROXY_TYPE_AUTO;
792 case NET_PROXY_TYPE_MANUAL:
793 *type = CONNECTION_PROXY_TYPE_MANUAL;
795 case NET_PROXY_TYPE_UNKNOWN:
797 return CONNECTION_ERROR_OPERATION_FAILED;
801 return CONNECTION_ERROR_NONE;
804 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
805 connection_address_family_e address_family, char** proxy_address)
807 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
809 if (!(_connection_libnet_check_profile_validity(profile)) ||
810 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
811 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
812 proxy_address == NULL) {
813 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
814 return CONNECTION_ERROR_INVALID_PARAMETER;
817 net_profile_info_t *profile_info = profile;
818 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
819 if (net_info == NULL)
820 return CONNECTION_ERROR_OPERATION_FAILED;
822 *proxy_address = g_strdup(net_info->ProxyAddr);
824 if (*proxy_address == NULL)
825 return CONNECTION_ERROR_OUT_OF_MEMORY;
827 return CONNECTION_ERROR_NONE;
830 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
831 connection_address_family_e address_family, connection_ip_config_type_e type)
833 net_ip_config_type_t *profile_type = NULL;
835 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
837 if (!(_connection_libnet_check_profile_validity(profile)) ||
838 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
839 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
840 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
841 return CONNECTION_ERROR_INVALID_PARAMETER;
844 net_profile_info_t *profile_info = profile;
845 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
846 if (net_info == NULL)
847 return CONNECTION_ERROR_OPERATION_FAILED;
849 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
850 profile_type = &net_info->IpConfigType ;
852 profile_type = &net_info->IpConfigType6 ;
854 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
857 case CONNECTION_IP_CONFIG_TYPE_STATIC:
858 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
859 net_info->IpAddr.Data.Ipv4.s_addr = 0;
860 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
861 net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
864 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
865 *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
868 case CONNECTION_IP_CONFIG_TYPE_AUTO:
869 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
872 case CONNECTION_IP_CONFIG_TYPE_FIXED:
873 net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
876 case CONNECTION_IP_CONFIG_TYPE_NONE:
877 *profile_type = NET_IP_CONFIG_TYPE_OFF;
881 return CONNECTION_ERROR_INVALID_PARAMETER;
887 case CONNECTION_IP_CONFIG_TYPE_STATIC:
888 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
889 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
890 net_info->PrefixLen6 = 0 ;
891 inet_pton(AF_INET6, "::",
892 &net_info->GatewayAddr6.Data.Ipv6);
895 case CONNECTION_IP_CONFIG_TYPE_AUTO:
896 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
899 case CONNECTION_IP_CONFIG_TYPE_NONE:
900 *profile_type = NET_IP_CONFIG_TYPE_OFF;
904 return CONNECTION_ERROR_INVALID_PARAMETER;
909 return CONNECTION_ERROR_NONE;
912 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
913 connection_address_family_e address_family, const char* ip_address)
915 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
917 if (!(_connection_libnet_check_profile_validity(profile)) ||
918 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
919 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
920 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
921 return CONNECTION_ERROR_INVALID_PARAMETER;
924 net_profile_info_t *profile_info = profile;
925 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
926 if (net_info == NULL)
927 return CONNECTION_ERROR_OPERATION_FAILED;
929 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
931 if (ip_address == NULL)
932 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
933 else if (inet_pton(AF_INET6, ip_address,
934 &net_info->IpAddr6.Data.Ipv6) < 1)
935 return CONNECTION_ERROR_INVALID_PARAMETER;
938 if (ip_address == NULL)
939 net_info->IpAddr.Data.Ipv4.s_addr = 0;
940 else if (inet_pton(AF_INET, ip_address,
941 &net_info->IpAddr.Data.Ipv4) < 1)
942 return CONNECTION_ERROR_INVALID_PARAMETER;
945 return CONNECTION_ERROR_NONE;
948 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
949 connection_address_family_e address_family, const char* subnet_mask)
951 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
953 if (!(_connection_libnet_check_profile_validity(profile)) ||
954 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
955 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
956 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
957 return CONNECTION_ERROR_INVALID_PARAMETER;
960 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
961 CONNECTION_LOG(CONNECTION_ERROR,
962 "Please uses connection_profile_set_prefix_length()");
963 return CONNECTION_ERROR_NOT_SUPPORTED;
966 net_profile_info_t *profile_info = profile;
967 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
968 if (net_info == NULL)
969 return CONNECTION_ERROR_OPERATION_FAILED;
971 if (subnet_mask == NULL)
972 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
973 else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4) < 1)
974 return CONNECTION_ERROR_INVALID_PARAMETER;
976 net_info->PrefixLen = __profile_convert_netmask_to_prefix_len(subnet_mask);
977 if (net_info->PrefixLen <= 0 || net_info->PrefixLen > 31) {
978 CONNECTION_LOG(CONNECTION_ERROR, "Invalid Prefix length: %d", net_info->PrefixLen);
979 return CONNECTION_ERROR_INVALID_PARAMETER;
982 return CONNECTION_ERROR_NONE;
985 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
986 connection_address_family_e address_family, const char* gateway_address)
988 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
990 if (!(_connection_libnet_check_profile_validity(profile)) ||
991 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
992 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
993 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
994 return CONNECTION_ERROR_INVALID_PARAMETER;
997 net_profile_info_t *profile_info = profile;
998 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
999 if (net_info == NULL)
1000 return CONNECTION_ERROR_OPERATION_FAILED;
1002 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1004 if (gateway_address == NULL)
1005 inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
1006 else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1)
1007 return CONNECTION_ERROR_INVALID_PARAMETER;
1010 if (gateway_address == NULL)
1011 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
1012 else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1)
1013 return CONNECTION_ERROR_INVALID_PARAMETER;
1016 return CONNECTION_ERROR_NONE;
1019 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
1020 connection_address_family_e address_family, const char* dns_address)
1022 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1024 if (!(_connection_libnet_check_profile_validity(profile)) ||
1025 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1026 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1028 order > NET_DNS_ADDR_MAX) {
1029 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1030 return CONNECTION_ERROR_INVALID_PARAMETER;
1033 net_profile_info_t *profile_info = profile;
1034 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1035 if (net_info == NULL)
1036 return CONNECTION_ERROR_OPERATION_FAILED;
1038 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1040 net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
1041 if (dns_address == NULL)
1042 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
1043 else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1)
1044 return CONNECTION_ERROR_INVALID_PARAMETER;
1045 if (net_info->DnsCount6 < order)
1046 net_info->DnsCount6 = order;
1049 net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
1050 if (dns_address == NULL)
1051 net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
1052 else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1)
1053 return CONNECTION_ERROR_INVALID_PARAMETER;
1054 if (net_info->DnsCount < order)
1055 net_info->DnsCount = order;
1058 return CONNECTION_ERROR_NONE;
1061 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
1063 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1065 if (!(_connection_libnet_check_profile_validity(profile))) {
1066 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1067 return CONNECTION_ERROR_INVALID_PARAMETER;
1070 net_profile_info_t *profile_info = profile;
1071 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1072 if (net_info == NULL)
1073 return CONNECTION_ERROR_OPERATION_FAILED;
1077 case CONNECTION_PROXY_TYPE_DIRECT:
1078 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
1080 case CONNECTION_PROXY_TYPE_AUTO:
1081 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
1083 case CONNECTION_PROXY_TYPE_MANUAL:
1084 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
1087 return CONNECTION_ERROR_INVALID_PARAMETER;
1091 return CONNECTION_ERROR_NONE;
1094 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
1095 connection_address_family_e address_family, const char* proxy_address)
1097 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1099 CONNECTION_LOG(CONNECTION_ERROR, "Address Family: ", address_family);
1100 if (!(_connection_libnet_check_profile_validity(profile)) ||
1101 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1102 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1103 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1104 return CONNECTION_ERROR_INVALID_PARAMETER;
1107 net_profile_info_t *profile_info = profile;
1108 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1109 if (net_info == NULL)
1110 return CONNECTION_ERROR_OPERATION_FAILED;
1112 if (proxy_address == NULL)
1113 net_info->ProxyAddr[0] = '\0';
1115 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
1117 return CONNECTION_ERROR_NONE;
1120 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
1121 connection_profile_state_changed_cb callback, void* user_data)
1123 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1125 if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
1126 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1127 return CONNECTION_ERROR_INVALID_PARAMETER;
1130 if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
1131 return CONNECTION_ERROR_NONE;
1133 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1136 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
1138 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1140 if (!(_connection_libnet_check_profile_validity(profile))) {
1141 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1142 return CONNECTION_ERROR_INVALID_PARAMETER;
1145 if (_connection_libnet_remove_from_profile_cb_list(profile) != true)
1146 return CONNECTION_ERROR_INVALID_PARAMETER;
1148 return CONNECTION_ERROR_NONE;
1152 /* Wi-Fi profile *************************************************************/
1153 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
1155 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1157 if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
1158 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1159 return CONNECTION_ERROR_INVALID_PARAMETER;
1162 net_profile_info_t *profile_info = profile;
1164 if (profile_info->profile_type != NET_DEVICE_WIFI)
1165 return CONNECTION_ERROR_INVALID_PARAMETER;
1167 *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
1169 return CONNECTION_ERROR_OUT_OF_MEMORY;
1171 return CONNECTION_ERROR_NONE;
1174 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
1176 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1178 if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
1179 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1180 return CONNECTION_ERROR_INVALID_PARAMETER;
1183 net_profile_info_t *profile_info = profile;
1185 if (profile_info->profile_type != NET_DEVICE_WIFI)
1186 return CONNECTION_ERROR_INVALID_PARAMETER;
1188 *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
1190 return CONNECTION_ERROR_OUT_OF_MEMORY;
1192 return CONNECTION_ERROR_NONE;
1195 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1197 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1199 if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
1200 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1201 return CONNECTION_ERROR_INVALID_PARAMETER;
1204 net_profile_info_t *profile_info = profile;
1206 if (profile_info->profile_type != NET_DEVICE_WIFI)
1207 return CONNECTION_ERROR_INVALID_PARAMETER;
1209 *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1211 return CONNECTION_ERROR_NONE;
1214 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1216 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1218 if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
1219 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1220 return CONNECTION_ERROR_INVALID_PARAMETER;
1223 net_profile_info_t *profile_info = profile;
1225 if (profile_info->profile_type != NET_DEVICE_WIFI)
1226 return CONNECTION_ERROR_INVALID_PARAMETER;
1228 *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1230 return CONNECTION_ERROR_NONE;
1233 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1235 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1237 if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
1238 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1239 return CONNECTION_ERROR_INVALID_PARAMETER;
1242 net_profile_info_t *profile_info = profile;
1244 if (profile_info->profile_type != NET_DEVICE_WIFI)
1245 return CONNECTION_ERROR_INVALID_PARAMETER;
1247 *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate / 1000000;
1249 return CONNECTION_ERROR_NONE;
1252 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e *type)
1254 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1256 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1257 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1258 return CONNECTION_ERROR_INVALID_PARAMETER;
1261 net_profile_info_t *profile_info = profile;
1263 if (profile_info->profile_type != NET_DEVICE_WIFI)
1264 return CONNECTION_ERROR_INVALID_PARAMETER;
1266 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1268 case WLAN_SEC_MODE_NONE:
1269 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1271 case WLAN_SEC_MODE_WEP:
1272 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1274 case WLAN_SEC_MODE_IEEE8021X:
1275 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1277 case WLAN_SEC_MODE_WPA_PSK:
1278 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1280 case WLAN_SEC_MODE_WPA2_PSK:
1281 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1284 return CONNECTION_ERROR_OPERATION_FAILED;
1288 return CONNECTION_ERROR_NONE;
1291 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e *type)
1293 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1295 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1296 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1297 return CONNECTION_ERROR_INVALID_PARAMETER;
1300 net_profile_info_t *profile_info = profile;
1302 if (profile_info->profile_type != NET_DEVICE_WIFI)
1303 return CONNECTION_ERROR_INVALID_PARAMETER;
1305 switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1307 case WLAN_ENC_MODE_NONE:
1308 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1310 case WLAN_ENC_MODE_WEP:
1311 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1313 case WLAN_ENC_MODE_TKIP:
1314 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1316 case WLAN_ENC_MODE_AES:
1317 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1319 case WLAN_ENC_MODE_TKIP_AES_MIXED:
1320 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1323 return CONNECTION_ERROR_OPERATION_FAILED;
1327 return CONNECTION_ERROR_NONE;
1330 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1332 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1334 if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1335 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1336 return CONNECTION_ERROR_INVALID_PARAMETER;
1339 net_profile_info_t *profile_info = profile;
1341 if (profile_info->profile_type != NET_DEVICE_WIFI)
1342 return CONNECTION_ERROR_INVALID_PARAMETER;
1344 if (profile_info->Favourite) {
1346 return CONNECTION_ERROR_NONE;
1349 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1351 case WLAN_SEC_MODE_NONE:
1354 case WLAN_SEC_MODE_WEP:
1355 case WLAN_SEC_MODE_IEEE8021X:
1356 case WLAN_SEC_MODE_WPA_PSK:
1357 case WLAN_SEC_MODE_WPA2_PSK:
1361 return CONNECTION_ERROR_OPERATION_FAILED;
1365 return CONNECTION_ERROR_NONE;
1368 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1370 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1372 if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1373 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1374 return CONNECTION_ERROR_INVALID_PARAMETER;
1377 net_profile_info_t *profile_info = profile;
1379 if (profile_info->profile_type != NET_DEVICE_WIFI)
1380 return CONNECTION_ERROR_INVALID_PARAMETER;
1382 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1383 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1385 return CONNECTION_ERROR_NONE;
1388 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1390 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1392 if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1393 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1394 return CONNECTION_ERROR_INVALID_PARAMETER;
1397 net_profile_info_t *profile_info = profile;
1399 if (profile_info->profile_type != NET_DEVICE_WIFI)
1400 return CONNECTION_ERROR_INVALID_PARAMETER;
1402 if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1407 return CONNECTION_ERROR_NONE;
1411 /* Cellular profile **********************************************************/
1412 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1413 connection_cellular_service_type_e* type)
1415 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1417 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1418 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1419 return CONNECTION_ERROR_INVALID_PARAMETER;
1422 net_profile_info_t *profile_info = profile;
1424 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1425 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1426 return CONNECTION_ERROR_INVALID_PARAMETER;
1429 *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1431 if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1432 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed"); //LCOV_EXCL_LINE
1433 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1436 return CONNECTION_ERROR_NONE;
1439 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1441 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1443 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1444 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1445 return CONNECTION_ERROR_INVALID_PARAMETER;
1448 net_profile_info_t *profile_info = profile;
1450 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1451 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1452 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1455 *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1457 return CONNECTION_ERROR_OUT_OF_MEMORY;
1459 return CONNECTION_ERROR_NONE;
1462 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1463 connection_cellular_auth_type_e *type, char** user_name, char** password)
1465 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1467 if (!(_connection_libnet_check_profile_validity(profile)) ||
1468 type == NULL || user_name == NULL || password == NULL) {
1469 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1470 return CONNECTION_ERROR_INVALID_PARAMETER;
1473 net_profile_info_t *profile_info = profile;
1475 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1476 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1477 return CONNECTION_ERROR_INVALID_PARAMETER;
1480 switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1482 case NET_PDP_AUTH_NONE:
1483 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1485 case NET_PDP_AUTH_PAP:
1486 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1488 case NET_PDP_AUTH_CHAP:
1489 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1492 return CONNECTION_ERROR_OPERATION_FAILED;
1496 *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1497 if (*user_name == NULL)
1498 return CONNECTION_ERROR_OUT_OF_MEMORY;
1500 *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1501 if (*password == NULL) {
1502 g_free(*user_name); //LCOV_EXCL_LINE
1503 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1506 return CONNECTION_ERROR_NONE;
1509 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1511 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1513 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1514 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1515 return CONNECTION_ERROR_INVALID_PARAMETER;
1518 net_profile_info_t *profile_info = profile;
1520 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1521 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1522 return CONNECTION_ERROR_INVALID_PARAMETER;
1525 *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1526 if (*home_url == NULL)
1527 return CONNECTION_ERROR_OUT_OF_MEMORY;
1529 return CONNECTION_ERROR_NONE;
1532 EXPORT_API int connection_profile_get_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1534 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1536 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1537 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1538 return CONNECTION_ERROR_INVALID_PARAMETER;
1541 net_profile_info_t *profile_info = profile;
1543 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1544 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1545 return CONNECTION_ERROR_INVALID_PARAMETER;
1548 switch (profile_info->ProfileInfo.Pdp.PdnType) {
1550 case NET_PDN_TYPE_UNKNOWN:
1551 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1553 case NET_PDN_TYPE_IPV4:
1554 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1556 case NET_PDN_TYPE_IPV6:
1557 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1559 case NET_PDN_TYPE_IPV4_IPV6:
1560 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1563 return CONNECTION_ERROR_OPERATION_FAILED;
1567 return CONNECTION_ERROR_NONE;
1570 EXPORT_API int connection_profile_get_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1572 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1574 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1575 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1576 return CONNECTION_ERROR_INVALID_PARAMETER;
1579 net_profile_info_t *profile_info = profile;
1581 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1582 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1583 return CONNECTION_ERROR_INVALID_PARAMETER;
1586 switch (profile_info->ProfileInfo.Pdp.RoamPdnType) {
1588 case NET_PDN_TYPE_UNKNOWN:
1589 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1591 case NET_PDN_TYPE_IPV4:
1592 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1594 case NET_PDN_TYPE_IPV6:
1595 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1597 case NET_PDN_TYPE_IPV4_IPV6:
1598 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1601 return CONNECTION_ERROR_OPERATION_FAILED;
1605 return CONNECTION_ERROR_NONE;
1608 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1610 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1612 if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1613 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1614 return CONNECTION_ERROR_INVALID_PARAMETER;
1617 net_profile_info_t *profile_info = profile;
1619 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1620 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1621 return CONNECTION_ERROR_INVALID_PARAMETER;
1624 if (profile_info->ProfileInfo.Pdp.Roaming)
1627 *is_roaming = false;
1629 return CONNECTION_ERROR_NONE;
1632 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
1634 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1636 if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
1637 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1638 return CONNECTION_ERROR_INVALID_PARAMETER;
1641 net_profile_info_t *profile_info = profile;
1643 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1644 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1645 return CONNECTION_ERROR_INVALID_PARAMETER;
1648 if (profile_info->ProfileInfo.Pdp.Hidden)
1653 return CONNECTION_ERROR_NONE;
1656 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
1658 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1660 if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
1661 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1662 return CONNECTION_ERROR_INVALID_PARAMETER;
1665 net_profile_info_t *profile_info = profile;
1667 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1668 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1669 return CONNECTION_ERROR_INVALID_PARAMETER;
1672 if (profile_info->ProfileInfo.Pdp.Editable)
1673 *is_editable = true;
1675 *is_editable = false;
1677 return CONNECTION_ERROR_NONE;
1680 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
1682 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1684 if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
1685 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1686 return CONNECTION_ERROR_INVALID_PARAMETER;
1689 net_profile_info_t *profile_info = profile;
1691 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1692 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1693 return CONNECTION_ERROR_INVALID_PARAMETER;
1696 if (profile_info->ProfileInfo.Pdp.DefaultConn)
1699 *is_default = false;
1701 return CONNECTION_ERROR_NONE;
1704 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
1705 connection_cellular_service_type_e service_type)
1707 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1709 if (!(_connection_libnet_check_profile_validity(profile))) {
1710 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1711 return CONNECTION_ERROR_INVALID_PARAMETER;
1714 net_profile_info_t *profile_info = profile;
1716 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1717 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1718 return CONNECTION_ERROR_INVALID_PARAMETER;
1721 switch (service_type) {
1723 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1724 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1726 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1727 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1729 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1730 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1732 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1733 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1735 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1736 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1738 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1739 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1741 case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1743 return CONNECTION_ERROR_INVALID_PARAMETER;
1747 return CONNECTION_ERROR_NONE;
1750 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1752 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1754 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1755 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1756 return CONNECTION_ERROR_INVALID_PARAMETER;
1759 net_profile_info_t *profile_info = profile;
1761 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1762 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1763 return CONNECTION_ERROR_INVALID_PARAMETER;
1766 g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1768 return CONNECTION_ERROR_NONE;
1771 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1772 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1774 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1776 if (!(_connection_libnet_check_profile_validity(profile)) ||
1777 user_name == NULL || password == NULL) {
1778 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1779 return CONNECTION_ERROR_INVALID_PARAMETER;
1782 net_profile_info_t *profile_info = profile;
1784 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1785 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1786 return CONNECTION_ERROR_INVALID_PARAMETER;
1791 case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1792 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1794 case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1795 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1797 case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1798 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1801 return CONNECTION_ERROR_INVALID_PARAMETER;
1805 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1806 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1808 return CONNECTION_ERROR_NONE;
1811 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1813 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1815 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1816 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1817 return CONNECTION_ERROR_INVALID_PARAMETER;
1820 net_profile_info_t *profile_info = profile;
1822 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1823 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1824 return CONNECTION_ERROR_INVALID_PARAMETER;
1827 g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1829 return CONNECTION_ERROR_NONE;
1832 EXPORT_API int connection_profile_set_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
1834 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1836 if (!(_connection_libnet_check_profile_validity(profile))) {
1837 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1838 return CONNECTION_ERROR_INVALID_PARAMETER;
1841 net_profile_info_t *profile_info = profile;
1843 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1844 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1845 return CONNECTION_ERROR_INVALID_PARAMETER;
1850 case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
1851 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4;
1853 case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
1854 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV6;
1856 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
1857 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
1858 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
1859 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
1861 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
1862 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
1865 return CONNECTION_ERROR_INVALID_PARAMETER;
1869 return CONNECTION_ERROR_NONE;
1872 EXPORT_API int connection_profile_set_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
1874 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1876 if (!(_connection_libnet_check_profile_validity(profile))) {
1877 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1878 return CONNECTION_ERROR_INVALID_PARAMETER;
1881 net_profile_info_t *profile_info = profile;
1883 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1884 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1885 return CONNECTION_ERROR_INVALID_PARAMETER;
1890 case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
1891 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4;
1893 case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
1894 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV6;
1896 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
1897 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
1898 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
1899 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
1901 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
1902 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
1905 return CONNECTION_ERROR_INVALID_PARAMETER;
1909 return CONNECTION_ERROR_NONE;
1912 EXPORT_API int connection_profile_get_ipv6_state(connection_profile_h profile, connection_profile_state_e *state)
1914 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1915 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1917 if (!(_connection_libnet_check_profile_validity(profile)) ||
1919 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1920 return CONNECTION_ERROR_INVALID_PARAMETER;
1923 net_profile_info_t *profile_info = profile;
1924 *state = _profile_convert_to_cp_state(profile_info->ProfileState6);
1926 return CONNECTION_ERROR_OPERATION_FAILED;
1928 return CONNECTION_ERROR_NONE;
1931 EXPORT_API int connection_profile_set_dns_config_type(connection_profile_h profile,
1932 connection_address_family_e address_family, connection_dns_config_type_e type)
1934 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1935 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1937 if (!(_connection_libnet_check_profile_validity(profile))) {
1938 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1939 return CONNECTION_ERROR_INVALID_PARAMETER;
1942 if ((address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1943 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1944 (type != CONNECTION_DNS_CONFIG_TYPE_STATIC &&
1945 type != CONNECTION_DNS_CONFIG_TYPE_DYNAMIC)) {
1946 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1947 return CONNECTION_ERROR_INVALID_PARAMETER;
1950 net_dns_config_type_t *profileType = NULL;
1951 net_dns_config_type_t *profileType6 = NULL;
1952 net_profile_info_t *profile_info = profile;
1954 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1955 if (net_info == NULL)
1956 return CONNECTION_ERROR_OPERATION_FAILED;
1958 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1959 profileType = &net_info->DnsConfigType;
1960 net_info->DnsAddr[0].Data.Ipv4.s_addr = 0;
1961 net_info->DnsAddr[1].Data.Ipv4.s_addr = 0;
1962 *profileType = type;
1964 profileType6 = &net_info->DnsConfigType6;
1965 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[0].Data.Ipv6);
1966 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[1].Data.Ipv6);
1967 *profileType6 = type;
1970 return CONNECTION_ERROR_NONE;
1973 EXPORT_API int connection_profile_get_dns_config_type(connection_profile_h profile,
1974 connection_address_family_e address_family, connection_dns_config_type_e *type)
1976 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1977 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1979 if (!(_connection_libnet_check_profile_validity(profile)) ||
1980 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1981 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1983 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1984 return CONNECTION_ERROR_INVALID_PARAMETER;
1987 net_dns_config_type_t profileType;
1988 net_profile_info_t *profile_info = profile;
1989 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1990 if (net_info == NULL)
1991 return CONNECTION_ERROR_OPERATION_FAILED;
1993 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
1994 profileType = net_info->DnsConfigType;
1996 profileType = net_info->DnsConfigType6;
1998 switch (profileType) {
1999 case NET_DNS_CONFIG_TYPE_STATIC:
2000 *type = CONNECTION_DNS_CONFIG_TYPE_STATIC;
2002 case NET_DNS_CONFIG_TYPE_DYNAMIC:
2003 *type = CONNECTION_DNS_CONFIG_TYPE_DYNAMIC;
2006 *type = CONNECTION_DNS_CONFIG_TYPE_NONE;
2010 return CONNECTION_ERROR_NONE;
2013 EXPORT_API int connection_profile_set_prefix_length(connection_profile_h profile,
2014 connection_address_family_e address_family, int prefix_len)
2016 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2017 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2019 if (!(_connection_libnet_check_profile_validity(profile)) ||
2020 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2021 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
2022 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2023 return CONNECTION_ERROR_INVALID_PARAMETER;
2026 net_profile_info_t *profile_info = profile;
2027 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2028 if (net_info == NULL)
2029 return CONNECTION_ERROR_OPERATION_FAILED;
2031 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
2032 net_info->PrefixLen = prefix_len;
2033 net_info->SubnetMask.Data.Ipv4.s_addr = __profile_convert_prefix_len_to_netmask(prefix_len);
2035 net_info->PrefixLen6 = prefix_len;
2037 return CONNECTION_ERROR_NONE;
2040 EXPORT_API int connection_profile_get_prefix_length(connection_profile_h profile,
2041 connection_address_family_e address_family, int *prefix_len)
2043 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2044 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2046 if (!(_connection_libnet_check_profile_validity(profile)) ||
2047 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2048 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2049 prefix_len == NULL) {
2050 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2051 return CONNECTION_ERROR_INVALID_PARAMETER;
2054 net_profile_info_t *profile_info = profile;
2055 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2056 if (net_info == NULL)
2057 return CONNECTION_ERROR_OPERATION_FAILED;
2059 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
2060 *prefix_len = net_info->PrefixLen;
2061 else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
2062 *prefix_len = net_info->PrefixLen6;
2064 return CONNECTION_ERROR_NONE;