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_IPV6)
576 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr6,
579 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
582 if (*ip_address == NULL)
583 return CONNECTION_ERROR_OUT_OF_MEMORY;
585 return CONNECTION_ERROR_NONE;
588 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
589 connection_address_family_e address_family, char** subnet_mask)
591 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
593 if (!(_connection_libnet_check_profile_validity(profile)) ||
594 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
595 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
596 subnet_mask == NULL) {
597 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
598 return CONNECTION_ERROR_INVALID_PARAMETER;
601 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
602 CONNECTION_LOG(CONNECTION_ERROR,
603 "Please uses connection_profile_get_prefix_length()");
604 return CONNECTION_ERROR_NOT_SUPPORTED;
607 net_profile_info_t *profile_info = profile;
608 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
609 if (net_info == NULL)
610 return CONNECTION_ERROR_OPERATION_FAILED;
612 *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask,
615 if (*subnet_mask == NULL)
616 return CONNECTION_ERROR_OUT_OF_MEMORY;
618 return CONNECTION_ERROR_NONE;
621 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
622 connection_address_family_e address_family, char** gateway_address)
624 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
626 if (!(_connection_libnet_check_profile_validity(profile)) ||
627 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
628 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
629 gateway_address == NULL) {
630 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
631 return CONNECTION_ERROR_INVALID_PARAMETER;
634 net_profile_info_t *profile_info = profile;
635 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
636 if (net_info == NULL)
637 return CONNECTION_ERROR_OPERATION_FAILED;
639 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
640 *gateway_address = __profile_convert_ip_to_string(
641 &net_info->GatewayAddr6, address_family);
643 *gateway_address = __profile_convert_ip_to_string(
644 &net_info->GatewayAddr, address_family);
646 if (*gateway_address == NULL)
647 return CONNECTION_ERROR_OUT_OF_MEMORY;
649 return CONNECTION_ERROR_NONE;
652 EXPORT_API int connection_profile_get_dhcp_server_address(
653 connection_profile_h profile,
654 connection_address_family_e address_family, char** dhcp_server)
656 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
658 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
659 CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
660 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
663 if (!(_connection_libnet_check_profile_validity(profile)) ||
664 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4) ||
665 dhcp_server == NULL) {
666 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
667 return CONNECTION_ERROR_INVALID_PARAMETER;
670 net_profile_info_t *profile_info = profile;
671 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
672 if (net_info == NULL)
673 return CONNECTION_ERROR_OPERATION_FAILED;
675 CONNECTION_LOG(CONNECTION_INFO, "IP Config %d, DHCP Server Address %s",
676 net_info->IpConfigType, (net_info->BServerAddr ? "TRUE" : "FALSE"));
678 *dhcp_server = __profile_convert_ip_to_string(&net_info->ServerAddr,
681 if (*dhcp_server == NULL)
682 return CONNECTION_ERROR_OUT_OF_MEMORY;
684 return CONNECTION_ERROR_NONE;
687 EXPORT_API int connection_profile_get_dhcp_lease_duration(
688 connection_profile_h profile,
689 connection_address_family_e address_family, int* dhcp_lease_duration)
691 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
693 if (!(_connection_libnet_check_profile_validity(profile)) ||
694 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
695 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
696 dhcp_lease_duration == NULL) {
697 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
698 return CONNECTION_ERROR_INVALID_PARAMETER;
701 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
702 CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
703 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
706 net_profile_info_t *profile_info = profile;
707 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
708 if (net_info == NULL)
709 return CONNECTION_ERROR_OPERATION_FAILED;
711 CONNECTION_LOG(CONNECTION_INFO, "Lease duration : %d",
712 net_info->DHCPLeaseDuration);
714 *dhcp_lease_duration = net_info->DHCPLeaseDuration;
716 return CONNECTION_ERROR_NONE;
719 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
720 connection_address_family_e address_family, char** dns_address)
722 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
724 if (!(_connection_libnet_check_profile_validity(profile)) ||
725 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
726 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
727 dns_address == NULL ||
729 order > NET_DNS_ADDR_MAX) {
730 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
731 return CONNECTION_ERROR_INVALID_PARAMETER;
734 net_profile_info_t *profile_info = profile;
735 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
736 if (net_info == NULL)
737 return CONNECTION_ERROR_OPERATION_FAILED;
739 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
740 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
742 else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) //LCOV_EXCL_LINE
743 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1], //LCOV_EXCL_LINE
746 if (*dns_address == NULL)
747 return CONNECTION_ERROR_OUT_OF_MEMORY;
749 return CONNECTION_ERROR_NONE;
752 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e *type)
754 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
756 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
757 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
758 return CONNECTION_ERROR_INVALID_PARAMETER;
761 net_profile_info_t *profile_info = profile;
762 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
763 if (net_info == NULL)
764 return CONNECTION_ERROR_OPERATION_FAILED;
767 if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
768 char *proxy = __profile_get_ethernet_proxy();
770 *type = CONNECTION_PROXY_TYPE_DIRECT;
772 *type = CONNECTION_PROXY_TYPE_MANUAL;
776 return CONNECTION_ERROR_NONE;
780 switch (net_info->ProxyMethod) {
782 case NET_PROXY_TYPE_DIRECT:
783 *type = CONNECTION_PROXY_TYPE_DIRECT;
785 case NET_PROXY_TYPE_AUTO:
786 *type = CONNECTION_PROXY_TYPE_AUTO;
788 case NET_PROXY_TYPE_MANUAL:
789 *type = CONNECTION_PROXY_TYPE_MANUAL;
791 case NET_PROXY_TYPE_UNKNOWN:
793 return CONNECTION_ERROR_OPERATION_FAILED;
797 return CONNECTION_ERROR_NONE;
800 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
801 connection_address_family_e address_family, char** proxy_address)
803 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
805 if (!(_connection_libnet_check_profile_validity(profile)) ||
806 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
807 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
808 proxy_address == NULL) {
809 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
810 return CONNECTION_ERROR_INVALID_PARAMETER;
813 net_profile_info_t *profile_info = profile;
814 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
815 if (net_info == NULL)
816 return CONNECTION_ERROR_OPERATION_FAILED;
818 *proxy_address = g_strdup(net_info->ProxyAddr);
820 if (*proxy_address == NULL)
821 return CONNECTION_ERROR_OUT_OF_MEMORY;
823 return CONNECTION_ERROR_NONE;
826 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
827 connection_address_family_e address_family, connection_ip_config_type_e type)
829 net_ip_config_type_t *profile_type = NULL;
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 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
837 return CONNECTION_ERROR_INVALID_PARAMETER;
840 net_profile_info_t *profile_info = profile;
841 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
842 if (net_info == NULL)
843 return CONNECTION_ERROR_OPERATION_FAILED;
845 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
846 profile_type = &net_info->IpConfigType ;
848 profile_type = &net_info->IpConfigType6 ;
850 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
853 case CONNECTION_IP_CONFIG_TYPE_STATIC:
854 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
855 net_info->IpAddr.Data.Ipv4.s_addr = 0;
856 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
857 net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
860 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
861 *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
864 case CONNECTION_IP_CONFIG_TYPE_AUTO:
865 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
868 case CONNECTION_IP_CONFIG_TYPE_FIXED:
869 net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
872 case CONNECTION_IP_CONFIG_TYPE_NONE:
873 *profile_type = NET_IP_CONFIG_TYPE_OFF;
877 return CONNECTION_ERROR_INVALID_PARAMETER;
883 case CONNECTION_IP_CONFIG_TYPE_STATIC:
884 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
885 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
886 net_info->PrefixLen6 = 0 ;
887 inet_pton(AF_INET6, "::",
888 &net_info->GatewayAddr6.Data.Ipv6);
891 case CONNECTION_IP_CONFIG_TYPE_AUTO:
892 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
895 case CONNECTION_IP_CONFIG_TYPE_NONE:
896 *profile_type = NET_IP_CONFIG_TYPE_OFF;
900 return CONNECTION_ERROR_INVALID_PARAMETER;
905 return CONNECTION_ERROR_NONE;
908 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
909 connection_address_family_e address_family, const char* ip_address)
911 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
913 if (!(_connection_libnet_check_profile_validity(profile)) ||
914 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
915 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
916 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
917 return CONNECTION_ERROR_INVALID_PARAMETER;
920 net_profile_info_t *profile_info = profile;
921 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
922 if (net_info == NULL)
923 return CONNECTION_ERROR_OPERATION_FAILED;
925 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
927 if (ip_address == NULL)
928 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
929 else if (inet_pton(AF_INET6, ip_address,
930 &net_info->IpAddr6.Data.Ipv6) < 1)
931 return CONNECTION_ERROR_INVALID_PARAMETER;
934 if (ip_address == NULL)
935 net_info->IpAddr.Data.Ipv4.s_addr = 0;
936 else if (inet_pton(AF_INET, ip_address,
937 &net_info->IpAddr.Data.Ipv4) < 1)
938 return CONNECTION_ERROR_INVALID_PARAMETER;
941 return CONNECTION_ERROR_NONE;
944 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
945 connection_address_family_e address_family, const char* subnet_mask)
947 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
949 if (!(_connection_libnet_check_profile_validity(profile)) ||
950 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
951 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
952 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
953 return CONNECTION_ERROR_INVALID_PARAMETER;
956 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
957 CONNECTION_LOG(CONNECTION_ERROR,
958 "Please uses connection_profile_set_prefix_length()");
959 return CONNECTION_ERROR_NOT_SUPPORTED;
962 net_profile_info_t *profile_info = profile;
963 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
964 if (net_info == NULL)
965 return CONNECTION_ERROR_OPERATION_FAILED;
967 if (subnet_mask == NULL)
968 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
969 else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4) < 1)
970 return CONNECTION_ERROR_INVALID_PARAMETER;
972 net_info->PrefixLen = __profile_convert_netmask_to_prefix_len(subnet_mask);
973 if (net_info->PrefixLen <= 0 || net_info->PrefixLen > 31) {
974 CONNECTION_LOG(CONNECTION_ERROR, "Invalid Prefix length: %d", net_info->PrefixLen);
975 return CONNECTION_ERROR_INVALID_PARAMETER;
978 return CONNECTION_ERROR_NONE;
981 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
982 connection_address_family_e address_family, const char* gateway_address)
984 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
986 if (!(_connection_libnet_check_profile_validity(profile)) ||
987 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
988 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
989 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
990 return CONNECTION_ERROR_INVALID_PARAMETER;
993 net_profile_info_t *profile_info = profile;
994 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
995 if (net_info == NULL)
996 return CONNECTION_ERROR_OPERATION_FAILED;
998 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1000 if (gateway_address == NULL)
1001 inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
1002 else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1)
1003 return CONNECTION_ERROR_INVALID_PARAMETER;
1006 if (gateway_address == NULL)
1007 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
1008 else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1)
1009 return CONNECTION_ERROR_INVALID_PARAMETER;
1012 return CONNECTION_ERROR_NONE;
1015 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
1016 connection_address_family_e address_family, const char* dns_address)
1018 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1020 if (!(_connection_libnet_check_profile_validity(profile)) ||
1021 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1022 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1024 order > NET_DNS_ADDR_MAX) {
1025 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1026 return CONNECTION_ERROR_INVALID_PARAMETER;
1029 net_profile_info_t *profile_info = profile;
1030 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1031 if (net_info == NULL)
1032 return CONNECTION_ERROR_OPERATION_FAILED;
1034 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1036 net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
1037 if (dns_address == NULL)
1038 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
1039 else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1)
1040 return CONNECTION_ERROR_INVALID_PARAMETER;
1041 if (net_info->DnsCount6 < order)
1042 net_info->DnsCount6 = order;
1045 net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
1046 if (dns_address == NULL)
1047 net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
1048 else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1)
1049 return CONNECTION_ERROR_INVALID_PARAMETER;
1050 if (net_info->DnsCount < order)
1051 net_info->DnsCount = order;
1054 return CONNECTION_ERROR_NONE;
1057 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
1059 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1061 if (!(_connection_libnet_check_profile_validity(profile))) {
1062 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1063 return CONNECTION_ERROR_INVALID_PARAMETER;
1066 net_profile_info_t *profile_info = profile;
1067 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1068 if (net_info == NULL)
1069 return CONNECTION_ERROR_OPERATION_FAILED;
1073 case CONNECTION_PROXY_TYPE_DIRECT:
1074 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
1076 case CONNECTION_PROXY_TYPE_AUTO:
1077 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
1079 case CONNECTION_PROXY_TYPE_MANUAL:
1080 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
1083 return CONNECTION_ERROR_INVALID_PARAMETER;
1087 return CONNECTION_ERROR_NONE;
1090 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
1091 connection_address_family_e address_family, const char* proxy_address)
1093 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1095 CONNECTION_LOG(CONNECTION_ERROR, "Address Family: ", address_family);
1096 if (!(_connection_libnet_check_profile_validity(profile)) ||
1097 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1098 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1099 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1100 return CONNECTION_ERROR_INVALID_PARAMETER;
1103 net_profile_info_t *profile_info = profile;
1104 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1105 if (net_info == NULL)
1106 return CONNECTION_ERROR_OPERATION_FAILED;
1108 if (proxy_address == NULL)
1109 net_info->ProxyAddr[0] = '\0';
1111 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
1113 return CONNECTION_ERROR_NONE;
1116 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
1117 connection_profile_state_changed_cb callback, void* user_data)
1119 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1121 if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
1122 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1123 return CONNECTION_ERROR_INVALID_PARAMETER;
1126 if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
1127 return CONNECTION_ERROR_NONE;
1129 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1132 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
1134 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1136 if (!(_connection_libnet_check_profile_validity(profile))) {
1137 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1138 return CONNECTION_ERROR_INVALID_PARAMETER;
1141 if (_connection_libnet_remove_from_profile_cb_list(profile) != true)
1142 return CONNECTION_ERROR_INVALID_PARAMETER;
1144 return CONNECTION_ERROR_NONE;
1148 /* Wi-Fi profile *************************************************************/
1149 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
1151 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1153 if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
1154 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1155 return CONNECTION_ERROR_INVALID_PARAMETER;
1158 net_profile_info_t *profile_info = profile;
1160 if (profile_info->profile_type != NET_DEVICE_WIFI)
1161 return CONNECTION_ERROR_INVALID_PARAMETER;
1163 *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
1165 return CONNECTION_ERROR_OUT_OF_MEMORY;
1167 return CONNECTION_ERROR_NONE;
1170 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
1172 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1174 if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
1175 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1176 return CONNECTION_ERROR_INVALID_PARAMETER;
1179 net_profile_info_t *profile_info = profile;
1181 if (profile_info->profile_type != NET_DEVICE_WIFI)
1182 return CONNECTION_ERROR_INVALID_PARAMETER;
1184 *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
1186 return CONNECTION_ERROR_OUT_OF_MEMORY;
1188 return CONNECTION_ERROR_NONE;
1191 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1193 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1195 if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
1196 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1197 return CONNECTION_ERROR_INVALID_PARAMETER;
1200 net_profile_info_t *profile_info = profile;
1202 if (profile_info->profile_type != NET_DEVICE_WIFI)
1203 return CONNECTION_ERROR_INVALID_PARAMETER;
1205 *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1207 return CONNECTION_ERROR_NONE;
1210 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1212 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1214 if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
1215 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1216 return CONNECTION_ERROR_INVALID_PARAMETER;
1219 net_profile_info_t *profile_info = profile;
1221 if (profile_info->profile_type != NET_DEVICE_WIFI)
1222 return CONNECTION_ERROR_INVALID_PARAMETER;
1224 *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1226 return CONNECTION_ERROR_NONE;
1229 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1231 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1233 if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
1234 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1235 return CONNECTION_ERROR_INVALID_PARAMETER;
1238 net_profile_info_t *profile_info = profile;
1240 if (profile_info->profile_type != NET_DEVICE_WIFI)
1241 return CONNECTION_ERROR_INVALID_PARAMETER;
1243 *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate / 1000000;
1245 return CONNECTION_ERROR_NONE;
1248 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e *type)
1250 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1252 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1253 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1254 return CONNECTION_ERROR_INVALID_PARAMETER;
1257 net_profile_info_t *profile_info = profile;
1259 if (profile_info->profile_type != NET_DEVICE_WIFI)
1260 return CONNECTION_ERROR_INVALID_PARAMETER;
1262 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1264 case WLAN_SEC_MODE_NONE:
1265 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1267 case WLAN_SEC_MODE_WEP:
1268 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1270 case WLAN_SEC_MODE_IEEE8021X:
1271 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1273 case WLAN_SEC_MODE_WPA_PSK:
1274 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1276 case WLAN_SEC_MODE_WPA2_PSK:
1277 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1280 return CONNECTION_ERROR_OPERATION_FAILED;
1284 return CONNECTION_ERROR_NONE;
1287 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e *type)
1289 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1291 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1292 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1293 return CONNECTION_ERROR_INVALID_PARAMETER;
1296 net_profile_info_t *profile_info = profile;
1298 if (profile_info->profile_type != NET_DEVICE_WIFI)
1299 return CONNECTION_ERROR_INVALID_PARAMETER;
1301 switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1303 case WLAN_ENC_MODE_NONE:
1304 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1306 case WLAN_ENC_MODE_WEP:
1307 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1309 case WLAN_ENC_MODE_TKIP:
1310 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1312 case WLAN_ENC_MODE_AES:
1313 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1315 case WLAN_ENC_MODE_TKIP_AES_MIXED:
1316 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1319 return CONNECTION_ERROR_OPERATION_FAILED;
1323 return CONNECTION_ERROR_NONE;
1326 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1328 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1330 if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1331 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1332 return CONNECTION_ERROR_INVALID_PARAMETER;
1335 net_profile_info_t *profile_info = profile;
1337 if (profile_info->profile_type != NET_DEVICE_WIFI)
1338 return CONNECTION_ERROR_INVALID_PARAMETER;
1340 if (profile_info->Favourite) {
1342 return CONNECTION_ERROR_NONE;
1345 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1347 case WLAN_SEC_MODE_NONE:
1350 case WLAN_SEC_MODE_WEP:
1351 case WLAN_SEC_MODE_IEEE8021X:
1352 case WLAN_SEC_MODE_WPA_PSK:
1353 case WLAN_SEC_MODE_WPA2_PSK:
1357 return CONNECTION_ERROR_OPERATION_FAILED;
1361 return CONNECTION_ERROR_NONE;
1364 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1366 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1368 if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1369 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1370 return CONNECTION_ERROR_INVALID_PARAMETER;
1373 net_profile_info_t *profile_info = profile;
1375 if (profile_info->profile_type != NET_DEVICE_WIFI)
1376 return CONNECTION_ERROR_INVALID_PARAMETER;
1378 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1379 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1381 return CONNECTION_ERROR_NONE;
1384 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1386 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1388 if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1389 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1390 return CONNECTION_ERROR_INVALID_PARAMETER;
1393 net_profile_info_t *profile_info = profile;
1395 if (profile_info->profile_type != NET_DEVICE_WIFI)
1396 return CONNECTION_ERROR_INVALID_PARAMETER;
1398 if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1403 return CONNECTION_ERROR_NONE;
1407 /* Cellular profile **********************************************************/
1408 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1409 connection_cellular_service_type_e* type)
1411 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1413 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1414 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1415 return CONNECTION_ERROR_INVALID_PARAMETER;
1418 net_profile_info_t *profile_info = profile;
1420 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1421 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1422 return CONNECTION_ERROR_INVALID_PARAMETER;
1425 *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1427 if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1428 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed"); //LCOV_EXCL_LINE
1429 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1432 return CONNECTION_ERROR_NONE;
1435 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1437 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1439 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1440 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1441 return CONNECTION_ERROR_INVALID_PARAMETER;
1444 net_profile_info_t *profile_info = profile;
1446 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1447 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1448 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1451 *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1453 return CONNECTION_ERROR_OUT_OF_MEMORY;
1455 return CONNECTION_ERROR_NONE;
1458 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1459 connection_cellular_auth_type_e *type, char** user_name, char** password)
1461 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1463 if (!(_connection_libnet_check_profile_validity(profile)) ||
1464 type == NULL || user_name == NULL || password == NULL) {
1465 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1466 return CONNECTION_ERROR_INVALID_PARAMETER;
1469 net_profile_info_t *profile_info = profile;
1471 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1472 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1473 return CONNECTION_ERROR_INVALID_PARAMETER;
1476 switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1478 case NET_PDP_AUTH_NONE:
1479 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1481 case NET_PDP_AUTH_PAP:
1482 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1484 case NET_PDP_AUTH_CHAP:
1485 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1488 return CONNECTION_ERROR_OPERATION_FAILED;
1492 *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1493 if (*user_name == NULL)
1494 return CONNECTION_ERROR_OUT_OF_MEMORY;
1496 *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1497 if (*password == NULL) {
1498 g_free(*user_name); //LCOV_EXCL_LINE
1499 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1502 return CONNECTION_ERROR_NONE;
1505 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1507 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1509 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1510 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1511 return CONNECTION_ERROR_INVALID_PARAMETER;
1514 net_profile_info_t *profile_info = profile;
1516 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1517 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1518 return CONNECTION_ERROR_INVALID_PARAMETER;
1521 *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1522 if (*home_url == NULL)
1523 return CONNECTION_ERROR_OUT_OF_MEMORY;
1525 return CONNECTION_ERROR_NONE;
1528 EXPORT_API int connection_profile_get_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1530 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1532 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1533 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1534 return CONNECTION_ERROR_INVALID_PARAMETER;
1537 net_profile_info_t *profile_info = profile;
1539 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1540 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1541 return CONNECTION_ERROR_INVALID_PARAMETER;
1544 switch (profile_info->ProfileInfo.Pdp.PdnType) {
1546 case NET_PDN_TYPE_UNKNOWN:
1547 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1549 case NET_PDN_TYPE_IPV4:
1550 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1552 case NET_PDN_TYPE_IPV6:
1553 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1555 case NET_PDN_TYPE_IPV4_IPV6:
1556 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1559 return CONNECTION_ERROR_OPERATION_FAILED;
1563 return CONNECTION_ERROR_NONE;
1566 EXPORT_API int connection_profile_get_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1568 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1570 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1571 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1572 return CONNECTION_ERROR_INVALID_PARAMETER;
1575 net_profile_info_t *profile_info = profile;
1577 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1578 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1579 return CONNECTION_ERROR_INVALID_PARAMETER;
1582 switch (profile_info->ProfileInfo.Pdp.RoamPdnType) {
1584 case NET_PDN_TYPE_UNKNOWN:
1585 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1587 case NET_PDN_TYPE_IPV4:
1588 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1590 case NET_PDN_TYPE_IPV6:
1591 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1593 case NET_PDN_TYPE_IPV4_IPV6:
1594 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1597 return CONNECTION_ERROR_OPERATION_FAILED;
1601 return CONNECTION_ERROR_NONE;
1604 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1606 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1608 if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1609 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1610 return CONNECTION_ERROR_INVALID_PARAMETER;
1613 net_profile_info_t *profile_info = profile;
1615 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1616 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1617 return CONNECTION_ERROR_INVALID_PARAMETER;
1620 if (profile_info->ProfileInfo.Pdp.Roaming)
1623 *is_roaming = false;
1625 return CONNECTION_ERROR_NONE;
1628 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
1630 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1632 if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
1633 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1634 return CONNECTION_ERROR_INVALID_PARAMETER;
1637 net_profile_info_t *profile_info = profile;
1639 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1640 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1641 return CONNECTION_ERROR_INVALID_PARAMETER;
1644 if (profile_info->ProfileInfo.Pdp.Hidden)
1649 return CONNECTION_ERROR_NONE;
1652 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
1654 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1656 if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
1657 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1658 return CONNECTION_ERROR_INVALID_PARAMETER;
1661 net_profile_info_t *profile_info = profile;
1663 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1664 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1665 return CONNECTION_ERROR_INVALID_PARAMETER;
1668 if (profile_info->ProfileInfo.Pdp.Editable)
1669 *is_editable = true;
1671 *is_editable = false;
1673 return CONNECTION_ERROR_NONE;
1676 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
1678 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1680 if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
1681 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1682 return CONNECTION_ERROR_INVALID_PARAMETER;
1685 net_profile_info_t *profile_info = profile;
1687 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1688 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1689 return CONNECTION_ERROR_INVALID_PARAMETER;
1692 if (profile_info->ProfileInfo.Pdp.DefaultConn)
1695 *is_default = false;
1697 return CONNECTION_ERROR_NONE;
1700 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
1701 connection_cellular_service_type_e service_type)
1703 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1705 if (!(_connection_libnet_check_profile_validity(profile))) {
1706 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1707 return CONNECTION_ERROR_INVALID_PARAMETER;
1710 net_profile_info_t *profile_info = profile;
1712 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1713 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1714 return CONNECTION_ERROR_INVALID_PARAMETER;
1717 switch (service_type) {
1719 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1720 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1722 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1723 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1725 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1726 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1728 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1729 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1731 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1732 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1734 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1735 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1737 case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1739 return CONNECTION_ERROR_INVALID_PARAMETER;
1743 return CONNECTION_ERROR_NONE;
1746 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1748 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1750 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1751 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1752 return CONNECTION_ERROR_INVALID_PARAMETER;
1755 net_profile_info_t *profile_info = profile;
1757 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1758 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1759 return CONNECTION_ERROR_INVALID_PARAMETER;
1762 g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1764 return CONNECTION_ERROR_NONE;
1767 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1768 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1770 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1772 if (!(_connection_libnet_check_profile_validity(profile)) ||
1773 user_name == NULL || password == NULL) {
1774 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1775 return CONNECTION_ERROR_INVALID_PARAMETER;
1778 net_profile_info_t *profile_info = profile;
1780 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1781 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1782 return CONNECTION_ERROR_INVALID_PARAMETER;
1787 case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1788 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1790 case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1791 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1793 case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1794 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1797 return CONNECTION_ERROR_INVALID_PARAMETER;
1801 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1802 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1804 return CONNECTION_ERROR_NONE;
1807 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1809 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1811 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1812 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1813 return CONNECTION_ERROR_INVALID_PARAMETER;
1816 net_profile_info_t *profile_info = profile;
1818 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1819 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1820 return CONNECTION_ERROR_INVALID_PARAMETER;
1823 g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1825 return CONNECTION_ERROR_NONE;
1828 EXPORT_API int connection_profile_set_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
1830 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1832 if (!(_connection_libnet_check_profile_validity(profile))) {
1833 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1834 return CONNECTION_ERROR_INVALID_PARAMETER;
1837 net_profile_info_t *profile_info = profile;
1839 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1840 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1841 return CONNECTION_ERROR_INVALID_PARAMETER;
1846 case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
1847 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4;
1849 case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
1850 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV6;
1852 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
1853 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
1854 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
1855 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
1857 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
1858 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
1861 return CONNECTION_ERROR_INVALID_PARAMETER;
1865 return CONNECTION_ERROR_NONE;
1868 EXPORT_API int connection_profile_set_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
1870 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1872 if (!(_connection_libnet_check_profile_validity(profile))) {
1873 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1874 return CONNECTION_ERROR_INVALID_PARAMETER;
1877 net_profile_info_t *profile_info = profile;
1879 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1880 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1881 return CONNECTION_ERROR_INVALID_PARAMETER;
1886 case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
1887 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4;
1889 case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
1890 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV6;
1892 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
1893 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
1894 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
1895 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
1897 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
1898 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
1901 return CONNECTION_ERROR_INVALID_PARAMETER;
1905 return CONNECTION_ERROR_NONE;
1908 EXPORT_API int connection_profile_get_ipv6_state(connection_profile_h profile, connection_profile_state_e *state)
1910 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1911 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1913 if (!(_connection_libnet_check_profile_validity(profile)) ||
1915 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1916 return CONNECTION_ERROR_INVALID_PARAMETER;
1919 net_profile_info_t *profile_info = profile;
1920 *state = _profile_convert_to_cp_state(profile_info->ProfileState6);
1922 return CONNECTION_ERROR_OPERATION_FAILED;
1924 return CONNECTION_ERROR_NONE;
1927 EXPORT_API int connection_profile_set_dns_config_type(connection_profile_h profile,
1928 connection_address_family_e address_family, connection_dns_config_type_e type)
1930 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1931 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1933 if (!(_connection_libnet_check_profile_validity(profile))) {
1934 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1935 return CONNECTION_ERROR_INVALID_PARAMETER;
1938 if ((address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1939 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1940 (type != CONNECTION_DNS_CONFIG_TYPE_STATIC &&
1941 type != CONNECTION_DNS_CONFIG_TYPE_DYNAMIC)) {
1942 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1943 return CONNECTION_ERROR_INVALID_PARAMETER;
1946 net_dns_config_type_t *profileType = NULL;
1947 net_dns_config_type_t *profileType6 = NULL;
1948 net_profile_info_t *profile_info = profile;
1950 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1951 if (net_info == NULL)
1952 return CONNECTION_ERROR_OPERATION_FAILED;
1954 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1955 profileType = &net_info->DnsConfigType;
1956 net_info->DnsAddr[0].Data.Ipv4.s_addr = 0;
1957 net_info->DnsAddr[1].Data.Ipv4.s_addr = 0;
1958 *profileType = type;
1960 profileType6 = &net_info->DnsConfigType6;
1961 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[0].Data.Ipv6);
1962 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[1].Data.Ipv6);
1963 *profileType6 = type;
1966 return CONNECTION_ERROR_NONE;
1969 EXPORT_API int connection_profile_get_dns_config_type(connection_profile_h profile,
1970 connection_address_family_e address_family, connection_dns_config_type_e *type)
1972 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1973 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1975 if (!(_connection_libnet_check_profile_validity(profile)) ||
1976 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1977 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1979 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1980 return CONNECTION_ERROR_INVALID_PARAMETER;
1983 net_dns_config_type_t profileType;
1984 net_profile_info_t *profile_info = profile;
1985 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1986 if (net_info == NULL)
1987 return CONNECTION_ERROR_OPERATION_FAILED;
1989 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
1990 profileType = net_info->DnsConfigType;
1992 profileType = net_info->DnsConfigType6;
1994 switch (profileType) {
1995 case NET_DNS_CONFIG_TYPE_STATIC:
1996 *type = CONNECTION_DNS_CONFIG_TYPE_STATIC;
1998 case NET_DNS_CONFIG_TYPE_DYNAMIC:
1999 *type = CONNECTION_DNS_CONFIG_TYPE_DYNAMIC;
2002 *type = CONNECTION_DNS_CONFIG_TYPE_NONE;
2006 return CONNECTION_ERROR_NONE;
2009 EXPORT_API int connection_profile_set_prefix_length(connection_profile_h profile,
2010 connection_address_family_e address_family, int prefix_len)
2012 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2013 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2015 if (!(_connection_libnet_check_profile_validity(profile)) ||
2016 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2017 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
2018 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2019 return CONNECTION_ERROR_INVALID_PARAMETER;
2022 net_profile_info_t *profile_info = profile;
2023 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2024 if (net_info == NULL)
2025 return CONNECTION_ERROR_OPERATION_FAILED;
2027 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
2028 net_info->PrefixLen = prefix_len;
2029 net_info->SubnetMask.Data.Ipv4.s_addr = __profile_convert_prefix_len_to_netmask(prefix_len);
2031 net_info->PrefixLen6 = prefix_len;
2033 return CONNECTION_ERROR_NONE;
2036 EXPORT_API int connection_profile_get_prefix_length(connection_profile_h profile,
2037 connection_address_family_e address_family, int *prefix_len)
2039 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2040 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2042 if (!(_connection_libnet_check_profile_validity(profile)) ||
2043 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2044 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2045 prefix_len == NULL) {
2046 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2047 return CONNECTION_ERROR_INVALID_PARAMETER;
2050 net_profile_info_t *profile_info = profile;
2051 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2052 if (net_info == NULL)
2053 return CONNECTION_ERROR_OPERATION_FAILED;
2055 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
2056 *prefix_len = net_info->PrefixLen;
2057 else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
2058 *prefix_len = net_info->PrefixLen6;
2060 return CONNECTION_ERROR_NONE;