2 * Copyright (c) 2011-2013 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
21 #include <arpa/inet.h>
22 #include <vconf/vconf.h>
24 #include "net_connection_private.h"
25 #include "connection_extension.h"
27 #define HTTP_PROXY "http_proxy"
28 #define MAX_PREFIX_LENGTH 6
30 static net_dev_info_t* __profile_get_net_info(net_profile_info_t *profile_info)
32 switch (profile_info->profile_type) {
33 case NET_DEVICE_CELLULAR:
34 return &profile_info->ProfileInfo.Pdp.net_info;
36 return &profile_info->ProfileInfo.Wlan.net_info;
37 case NET_DEVICE_ETHERNET:
38 return &profile_info->ProfileInfo.Ethernet.net_info; //LCOV_EXCL_LINE
39 case NET_DEVICE_BLUETOOTH:
40 return &profile_info->ProfileInfo.Bluetooth.net_info;
42 return &profile_info->ProfileInfo.Mesh.net_info;
43 case NET_DEVICE_DEFAULT:
45 case NET_DEVICE_UNKNOWN:
52 static char *__profile_convert_ip_to_string(net_addr_t *ip_addr, connection_address_family_e address_family)
54 unsigned char *ipaddr = NULL;
57 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
58 ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
59 ipstr = g_try_malloc0(INET_ADDRSTRLEN);
63 inet_ntop(AF_INET, ipaddr, ipstr, INET_ADDRSTRLEN);
66 ipaddr = (unsigned char *)&ip_addr->Data.Ipv6.s6_addr;
67 ipstr = g_try_malloc0(INET6_ADDRSTRLEN);
71 inet_ntop(AF_INET6, ipaddr, ipstr, INET6_ADDRSTRLEN);
78 static void __profile_init_cellular_profile(net_profile_info_t *profile_info, const char *keyword)
80 int default_subscriber_id = 0;
81 connection_profile_h profile = NULL;
83 profile_info->profile_type = NET_DEVICE_CELLULAR;
84 profile_info->ProfileState = NET_STATE_TYPE_IDLE;
85 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_UNKNOWN;
86 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_UNKNOWN;
87 profile_info->ProfileInfo.Pdp.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
88 profile_info->ProfileInfo.Pdp.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
89 g_strlcpy(profile_info->ProfileInfo.Pdp.Keyword, keyword, NET_PDP_APN_LEN_MAX);
91 if (vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE,
92 &default_subscriber_id) != 0)
93 CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
94 "Failed to get VCONF_TELEPHONY_DEFAULT_DATA_SERVICE");
96 profile = (connection_profile_h)profile_info;
97 _connection_libnet_set_cellular_subscriber_id(profile, default_subscriber_id);
100 static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
102 profile_info->profile_type = NET_DEVICE_WIFI;
103 profile_info->ProfileState = NET_STATE_TYPE_IDLE;
104 profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
105 profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
106 profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
107 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
108 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
112 static char* __profile_get_ethernet_proxy(void)
116 proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
119 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
127 static unsigned char __profile_convert_netmask_to_prefix_len(const char *netmask)
132 in_addr_t mask = inet_network(netmask);
133 in_addr_t host = ~mask;
134 unsigned char prefix_len = 0;
136 /* a valid netmask must be 2^n - 1 */
137 if ((host & (host + 1)) != 0)
140 for (; mask; mask <<= 1)
146 static in_addr_t __profile_convert_prefix_len_to_netmask(int prefix_len)
148 return (prefix_len ? (in_addr_t) 0xFFFFFFFFu >> (32 - prefix_len) : 0);
152 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
155 case NET_SERVICE_INTERNET:
156 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
157 case NET_SERVICE_MMS:
158 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
159 case NET_SERVICE_PREPAID_INTERNET:
160 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
161 case NET_SERVICE_PREPAID_MMS:
162 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
163 case NET_SERVICE_TETHERING:
164 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
165 case NET_SERVICE_APPLICATION:
166 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
168 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
172 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
174 connection_profile_state_e cp_state;
177 case NET_STATE_TYPE_ONLINE:
178 case NET_STATE_TYPE_READY:
179 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
181 case NET_STATE_TYPE_IDLE:
182 case NET_STATE_TYPE_FAILURE:
183 case NET_STATE_TYPE_DISCONNECT:
184 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
186 case NET_STATE_TYPE_ASSOCIATION:
187 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
189 case NET_STATE_TYPE_CONFIGURATION:
190 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
199 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
202 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
203 return NET_SERVICE_INTERNET;
204 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
205 return NET_SERVICE_MMS;
206 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
207 return NET_SERVICE_PREPAID_INTERNET;
208 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
209 return NET_SERVICE_PREPAID_MMS;
210 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
211 return NET_SERVICE_TETHERING;
212 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
213 return NET_SERVICE_APPLICATION;
215 return NET_SERVICE_UNKNOWN;
219 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
221 net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
224 case CONNECTION_PROFILE_STATE_CONNECTED:
225 libnet_state = NET_STATE_TYPE_ONLINE;
227 case CONNECTION_PROFILE_STATE_DISCONNECTED:
228 libnet_state = NET_STATE_TYPE_IDLE;
230 case CONNECTION_PROFILE_STATE_ASSOCIATION:
231 libnet_state = NET_STATE_TYPE_ASSOCIATION;
233 case CONNECTION_PROFILE_STATE_CONFIGURATION:
234 libnet_state = NET_STATE_TYPE_CONFIGURATION;
242 /* Connection profile ********************************************************/
243 EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
245 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
247 if (type == CONNECTION_PROFILE_TYPE_CELLULAR)
248 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
249 else if (type == CONNECTION_PROFILE_TYPE_WIFI)
250 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
252 if (type != CONNECTION_PROFILE_TYPE_CELLULAR &&
253 type != CONNECTION_PROFILE_TYPE_WIFI) {
254 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
255 return CONNECTION_ERROR_INVALID_PARAMETER;
258 if (profile == NULL) {
259 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
260 return CONNECTION_ERROR_INVALID_PARAMETER;
263 int rv = _connection_libnet_check_profile_privilege();
264 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
266 else if (rv != CONNECTION_ERROR_NONE) {
267 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create profile"); //LCOV_EXCL_LINE
268 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
271 net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
272 if (profile_info == NULL)
273 return CONNECTION_ERROR_OUT_OF_MEMORY;
275 if (type == CONNECTION_PROFILE_TYPE_CELLULAR) {
276 if (keyword == NULL) {
277 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
278 g_free(profile_info);
279 return CONNECTION_ERROR_INVALID_PARAMETER;
281 __profile_init_cellular_profile(profile_info, keyword);
282 } else if (type == CONNECTION_PROFILE_TYPE_WIFI) {
283 __profile_init_wifi_profile(profile_info);
286 *profile = (connection_profile_h)profile_info;
287 _connection_libnet_add_to_profile_list(*profile);
289 return CONNECTION_ERROR_NONE;
292 EXPORT_API int connection_profile_destroy(connection_profile_h profile)
294 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
296 if (!(_connection_libnet_check_profile_validity(profile))) {
297 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
298 return CONNECTION_ERROR_INVALID_PARAMETER;
301 _connection_libnet_remove_from_profile_list(profile);
303 return CONNECTION_ERROR_NONE;
306 EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
308 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
310 if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
311 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
312 return CONNECTION_ERROR_INVALID_PARAMETER;
315 *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
316 if (*cloned_profile == NULL)
317 return CONNECTION_ERROR_OUT_OF_MEMORY;
319 memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
320 _connection_libnet_add_to_profile_list(*cloned_profile);
322 return CONNECTION_ERROR_NONE;
325 EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
327 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
329 if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
330 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
331 return CONNECTION_ERROR_INVALID_PARAMETER;
334 net_profile_info_t *profile_info = profile;
336 char *prof_id = strrchr(profile_info->ProfileName, '/');
338 return CONNECTION_ERROR_INVALID_PARAMETER;
341 *profile_id = g_strdup(prof_id);
343 if (*profile_id == NULL)
344 return CONNECTION_ERROR_OUT_OF_MEMORY;
346 return CONNECTION_ERROR_NONE;
349 EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
351 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
353 if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
354 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
355 return CONNECTION_ERROR_INVALID_PARAMETER;
358 net_profile_info_t *profile_info = profile;
360 switch (profile_info->profile_type) {
361 case NET_DEVICE_CELLULAR:
362 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
364 case NET_DEVICE_WIFI:
365 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
367 case NET_DEVICE_ETHERNET:
368 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName); //LCOV_EXCL_LINE
369 break; //LCOV_EXCL_LINE
370 case NET_DEVICE_BLUETOOTH: {
371 char *bt_name = strrchr(profile_info->ProfileName, '/');
373 return CONNECTION_ERROR_INVALID_PARAMETER;
376 *profile_name = g_strdup(bt_name);
378 case NET_DEVICE_MESH:
379 *profile_name = g_strdup(profile_info->ProfileInfo.Mesh.essid);
382 return CONNECTION_ERROR_INVALID_PARAMETER;
385 if (*profile_name == NULL)
386 return CONNECTION_ERROR_OUT_OF_MEMORY;
388 return CONNECTION_ERROR_NONE;
391 EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e *type)
393 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
395 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
396 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
397 return CONNECTION_ERROR_INVALID_PARAMETER;
400 net_profile_info_t *profile_info = profile;
402 switch (profile_info->profile_type) {
403 case NET_DEVICE_CELLULAR:
404 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
406 case NET_DEVICE_WIFI:
407 *type = CONNECTION_PROFILE_TYPE_WIFI;
409 case NET_DEVICE_ETHERNET:
410 *type = CONNECTION_PROFILE_TYPE_ETHERNET; //LCOV_EXCL_LINE
411 break; //LCOV_EXCL_LINE
412 case NET_DEVICE_BLUETOOTH:
413 *type = CONNECTION_PROFILE_TYPE_BT;
415 case NET_DEVICE_MESH:
416 *type = CONNECTION_PROFILE_TYPE_MESH;
419 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type");
420 return CONNECTION_ERROR_OPERATION_FAILED;
423 return CONNECTION_ERROR_NONE;
426 EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
428 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
430 if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
431 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
432 return CONNECTION_ERROR_INVALID_PARAMETER;
435 net_profile_info_t *profile_info = profile;
436 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
437 if (net_info == NULL)
438 return CONNECTION_ERROR_INVALID_PARAMETER;
440 *interface_name = g_strdup(net_info->DevName);
441 if (*interface_name == NULL)
442 return CONNECTION_ERROR_OUT_OF_MEMORY;
444 return CONNECTION_ERROR_NONE;
447 EXPORT_API int connection_profile_refresh(connection_profile_h profile)
451 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
453 if (!(_connection_libnet_check_profile_validity(profile))) {
454 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
455 return CONNECTION_ERROR_INVALID_PARAMETER;
458 net_profile_info_t profile_info_local;
459 net_profile_info_t *profile_info = profile;
461 rv = net_get_profile_info(profile_info->ProfileName, &profile_info_local);
462 if (rv == NET_ERR_ACCESS_DENIED) {
463 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
464 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
465 } else if (rv != NET_ERR_NONE) {
466 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile information"); //LCOV_EXCL_LINE
467 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
470 memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
472 return CONNECTION_ERROR_NONE;
475 EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
477 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
479 if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
480 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
481 return CONNECTION_ERROR_INVALID_PARAMETER;
484 net_profile_info_t *profile_info = profile;
485 *state = _profile_convert_to_cp_state(profile_info->ProfileState);
487 return CONNECTION_ERROR_NONE;
490 EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
491 connection_address_family_e address_family, connection_ip_config_type_e *type)
493 net_ip_config_type_t profile_type;
495 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
497 if (!(_connection_libnet_check_profile_validity(profile)) ||
498 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
499 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
501 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
502 return CONNECTION_ERROR_INVALID_PARAMETER;
505 net_profile_info_t *profile_info = profile;
506 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
507 if (net_info == NULL)
508 return CONNECTION_ERROR_OPERATION_FAILED;
510 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
511 profile_type = net_info->IpConfigType;
513 profile_type = net_info->IpConfigType6;
515 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
516 switch (profile_type) {
518 case NET_IP_CONFIG_TYPE_STATIC:
519 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
522 case NET_IP_CONFIG_TYPE_DYNAMIC:
523 *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
526 case NET_IP_CONFIG_TYPE_AUTO_IP:
527 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
530 case NET_IP_CONFIG_TYPE_FIXED:
531 *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
534 case NET_IP_CONFIG_TYPE_OFF:
535 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
538 return CONNECTION_ERROR_OPERATION_FAILED;
543 switch (profile_type) {
544 case NET_IP_CONFIG_TYPE_STATIC:
545 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
548 case NET_IP_CONFIG_TYPE_AUTO_IP:
549 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
552 case NET_IP_CONFIG_TYPE_OFF:
553 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
557 return CONNECTION_ERROR_OPERATION_FAILED;
563 return CONNECTION_ERROR_NONE;
566 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
567 connection_address_family_e address_family, char** ip_address)
569 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
571 if (!(_connection_libnet_check_profile_validity(profile)) ||
572 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
573 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
574 ip_address == NULL) {
575 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
576 return CONNECTION_ERROR_INVALID_PARAMETER;
579 net_profile_info_t *profile_info = profile;
580 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
581 if (net_info == NULL)
582 return CONNECTION_ERROR_OPERATION_FAILED;
584 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
585 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
588 if (net_get_preferred_ipv6_address(net_info->ProfileName, ip_address) != NET_ERR_NONE) {
589 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get preferred ipv6 address");
590 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
595 if (*ip_address == NULL)
596 return CONNECTION_ERROR_OUT_OF_MEMORY;
598 return CONNECTION_ERROR_NONE;
601 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
602 connection_address_family_e address_family, char** subnet_mask)
604 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
606 if (!(_connection_libnet_check_profile_validity(profile)) ||
607 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
608 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
609 subnet_mask == NULL) {
610 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
611 return CONNECTION_ERROR_INVALID_PARAMETER;
614 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
615 CONNECTION_LOG(CONNECTION_ERROR,
616 "Please uses connection_profile_get_prefix_length()");
617 return CONNECTION_ERROR_NOT_SUPPORTED;
620 net_profile_info_t *profile_info = profile;
621 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
622 if (net_info == NULL)
623 return CONNECTION_ERROR_OPERATION_FAILED;
625 *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask,
628 if (*subnet_mask == NULL)
629 return CONNECTION_ERROR_OUT_OF_MEMORY;
631 return CONNECTION_ERROR_NONE;
634 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
635 connection_address_family_e address_family, char** gateway_address)
637 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
639 if (!(_connection_libnet_check_profile_validity(profile)) ||
640 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
641 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
642 gateway_address == NULL) {
643 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
644 return CONNECTION_ERROR_INVALID_PARAMETER;
647 net_profile_info_t *profile_info = profile;
648 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
649 if (net_info == NULL)
650 return CONNECTION_ERROR_OPERATION_FAILED;
652 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
653 *gateway_address = __profile_convert_ip_to_string(
654 &net_info->GatewayAddr6, address_family);
656 *gateway_address = __profile_convert_ip_to_string(
657 &net_info->GatewayAddr, address_family);
659 if (*gateway_address == NULL)
660 return CONNECTION_ERROR_OUT_OF_MEMORY;
662 return CONNECTION_ERROR_NONE;
665 EXPORT_API int connection_profile_get_dhcp_server_address(
666 connection_profile_h profile,
667 connection_address_family_e address_family, char** dhcp_server)
669 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
671 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
672 CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
673 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
676 if (!(_connection_libnet_check_profile_validity(profile)) ||
677 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4) ||
678 dhcp_server == NULL) {
679 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
680 return CONNECTION_ERROR_INVALID_PARAMETER;
683 net_profile_info_t *profile_info = profile;
684 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
685 if (net_info == NULL)
686 return CONNECTION_ERROR_OPERATION_FAILED;
688 CONNECTION_LOG(CONNECTION_INFO, "IP Config %d, DHCP Server Address %s",
689 net_info->IpConfigType, (net_info->BServerAddr ? "TRUE" : "FALSE"));
691 *dhcp_server = __profile_convert_ip_to_string(&net_info->ServerAddr,
694 if (*dhcp_server == NULL)
695 return CONNECTION_ERROR_OUT_OF_MEMORY;
697 return CONNECTION_ERROR_NONE;
700 EXPORT_API int connection_profile_get_dhcp_lease_duration(
701 connection_profile_h profile,
702 connection_address_family_e address_family, int* dhcp_lease_duration)
704 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
706 if (!(_connection_libnet_check_profile_validity(profile)) ||
707 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
708 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
709 dhcp_lease_duration == NULL) {
710 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
711 return CONNECTION_ERROR_INVALID_PARAMETER;
714 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
715 CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
716 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
719 net_profile_info_t *profile_info = profile;
720 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
721 if (net_info == NULL)
722 return CONNECTION_ERROR_OPERATION_FAILED;
724 CONNECTION_LOG(CONNECTION_INFO, "Lease duration : %d",
725 net_info->DHCPLeaseDuration);
727 *dhcp_lease_duration = net_info->DHCPLeaseDuration;
729 return CONNECTION_ERROR_NONE;
732 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
733 connection_address_family_e address_family, char** dns_address)
735 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
737 if (!(_connection_libnet_check_profile_validity(profile)) ||
738 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
739 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
740 dns_address == NULL ||
742 order > NET_DNS_ADDR_MAX) {
743 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
744 return CONNECTION_ERROR_INVALID_PARAMETER;
747 net_profile_info_t *profile_info = profile;
748 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
749 if (net_info == NULL)
750 return CONNECTION_ERROR_OPERATION_FAILED;
752 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
753 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
755 else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) //LCOV_EXCL_LINE
756 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1], //LCOV_EXCL_LINE
759 if (*dns_address == NULL)
760 return CONNECTION_ERROR_OUT_OF_MEMORY;
762 return CONNECTION_ERROR_NONE;
765 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e *type)
767 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
769 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
770 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
771 return CONNECTION_ERROR_INVALID_PARAMETER;
774 net_profile_info_t *profile_info = profile;
775 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
776 if (net_info == NULL)
777 return CONNECTION_ERROR_OPERATION_FAILED;
780 if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
781 char *proxy = __profile_get_ethernet_proxy();
783 *type = CONNECTION_PROXY_TYPE_DIRECT;
785 *type = CONNECTION_PROXY_TYPE_MANUAL;
789 return CONNECTION_ERROR_NONE;
793 switch (net_info->ProxyMethod) {
795 case NET_PROXY_TYPE_DIRECT:
796 *type = CONNECTION_PROXY_TYPE_DIRECT;
798 case NET_PROXY_TYPE_AUTO:
799 *type = CONNECTION_PROXY_TYPE_AUTO;
801 case NET_PROXY_TYPE_MANUAL:
802 *type = CONNECTION_PROXY_TYPE_MANUAL;
804 case NET_PROXY_TYPE_UNKNOWN:
806 return CONNECTION_ERROR_OPERATION_FAILED;
810 return CONNECTION_ERROR_NONE;
813 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
814 connection_address_family_e address_family, char** proxy_address)
816 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
818 if (!(_connection_libnet_check_profile_validity(profile)) ||
819 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
820 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
821 proxy_address == NULL) {
822 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
823 return CONNECTION_ERROR_INVALID_PARAMETER;
826 net_profile_info_t *profile_info = profile;
827 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
828 if (net_info == NULL)
829 return CONNECTION_ERROR_OPERATION_FAILED;
831 *proxy_address = g_strdup(net_info->ProxyAddr);
833 if (*proxy_address == NULL)
834 return CONNECTION_ERROR_OUT_OF_MEMORY;
836 return CONNECTION_ERROR_NONE;
839 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
840 connection_address_family_e address_family, connection_ip_config_type_e type)
842 net_ip_config_type_t *profile_type = NULL;
844 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
846 if (!(_connection_libnet_check_profile_validity(profile)) ||
847 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
848 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
849 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
850 return CONNECTION_ERROR_INVALID_PARAMETER;
853 net_profile_info_t *profile_info = profile;
854 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
855 if (net_info == NULL)
856 return CONNECTION_ERROR_OPERATION_FAILED;
858 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
859 profile_type = &net_info->IpConfigType ;
861 profile_type = &net_info->IpConfigType6 ;
863 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
866 case CONNECTION_IP_CONFIG_TYPE_STATIC:
867 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
868 net_info->IpAddr.Data.Ipv4.s_addr = 0;
869 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
870 net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
873 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
874 *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
877 case CONNECTION_IP_CONFIG_TYPE_AUTO:
878 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
881 case CONNECTION_IP_CONFIG_TYPE_FIXED:
882 net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
885 case CONNECTION_IP_CONFIG_TYPE_NONE:
886 *profile_type = NET_IP_CONFIG_TYPE_OFF;
890 return CONNECTION_ERROR_INVALID_PARAMETER;
896 case CONNECTION_IP_CONFIG_TYPE_STATIC:
897 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
898 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
899 net_info->PrefixLen6 = 0 ;
900 inet_pton(AF_INET6, "::",
901 &net_info->GatewayAddr6.Data.Ipv6);
904 case CONNECTION_IP_CONFIG_TYPE_AUTO:
905 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
908 case CONNECTION_IP_CONFIG_TYPE_NONE:
909 *profile_type = NET_IP_CONFIG_TYPE_OFF;
913 return CONNECTION_ERROR_INVALID_PARAMETER;
918 return CONNECTION_ERROR_NONE;
921 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
922 connection_address_family_e address_family, const char* ip_address)
924 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
926 if (!(_connection_libnet_check_profile_validity(profile)) ||
927 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
928 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
929 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
930 return CONNECTION_ERROR_INVALID_PARAMETER;
933 net_profile_info_t *profile_info = profile;
934 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
935 if (net_info == NULL)
936 return CONNECTION_ERROR_OPERATION_FAILED;
938 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
940 if (ip_address == NULL)
941 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
942 else if (inet_pton(AF_INET6, ip_address,
943 &net_info->IpAddr6.Data.Ipv6) < 1)
944 return CONNECTION_ERROR_INVALID_PARAMETER;
947 if (ip_address == NULL)
948 net_info->IpAddr.Data.Ipv4.s_addr = 0;
949 else if (inet_pton(AF_INET, ip_address,
950 &net_info->IpAddr.Data.Ipv4) < 1)
951 return CONNECTION_ERROR_INVALID_PARAMETER;
954 return CONNECTION_ERROR_NONE;
957 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
958 connection_address_family_e address_family, const char* subnet_mask)
960 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
962 if (!(_connection_libnet_check_profile_validity(profile)) ||
963 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
964 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
965 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
966 return CONNECTION_ERROR_INVALID_PARAMETER;
969 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
970 CONNECTION_LOG(CONNECTION_ERROR,
971 "Please uses connection_profile_set_prefix_length()");
972 return CONNECTION_ERROR_NOT_SUPPORTED;
975 net_profile_info_t *profile_info = profile;
976 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
977 if (net_info == NULL)
978 return CONNECTION_ERROR_OPERATION_FAILED;
980 if (subnet_mask == NULL)
981 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
982 else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4) < 1)
983 return CONNECTION_ERROR_INVALID_PARAMETER;
985 net_info->PrefixLen = __profile_convert_netmask_to_prefix_len(subnet_mask);
986 if (net_info->PrefixLen <= 0 || net_info->PrefixLen > 31) {
987 CONNECTION_LOG(CONNECTION_ERROR, "Invalid Prefix length: %d", net_info->PrefixLen);
988 return CONNECTION_ERROR_INVALID_PARAMETER;
991 return CONNECTION_ERROR_NONE;
994 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
995 connection_address_family_e address_family, const char* gateway_address)
997 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
999 if (!(_connection_libnet_check_profile_validity(profile)) ||
1000 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1001 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1002 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1003 return CONNECTION_ERROR_INVALID_PARAMETER;
1006 net_profile_info_t *profile_info = profile;
1007 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1008 if (net_info == NULL)
1009 return CONNECTION_ERROR_OPERATION_FAILED;
1011 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1013 if (gateway_address == NULL)
1014 inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
1015 else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1)
1016 return CONNECTION_ERROR_INVALID_PARAMETER;
1019 if (gateway_address == NULL)
1020 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
1021 else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1)
1022 return CONNECTION_ERROR_INVALID_PARAMETER;
1025 return CONNECTION_ERROR_NONE;
1028 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
1029 connection_address_family_e address_family, const char* dns_address)
1031 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1033 if (!(_connection_libnet_check_profile_validity(profile)) ||
1034 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1035 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1037 order > NET_DNS_ADDR_MAX) {
1038 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1039 return CONNECTION_ERROR_INVALID_PARAMETER;
1042 net_profile_info_t *profile_info = profile;
1043 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1044 if (net_info == NULL)
1045 return CONNECTION_ERROR_OPERATION_FAILED;
1047 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1049 net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
1050 if (dns_address == NULL)
1051 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
1052 else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1)
1053 return CONNECTION_ERROR_INVALID_PARAMETER;
1054 if (net_info->DnsCount6 < order)
1055 net_info->DnsCount6 = order;
1058 net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
1059 if (dns_address == NULL)
1060 net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
1061 else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1)
1062 return CONNECTION_ERROR_INVALID_PARAMETER;
1063 if (net_info->DnsCount < order)
1064 net_info->DnsCount = order;
1067 return CONNECTION_ERROR_NONE;
1070 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
1072 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1074 if (!(_connection_libnet_check_profile_validity(profile))) {
1075 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1076 return CONNECTION_ERROR_INVALID_PARAMETER;
1079 net_profile_info_t *profile_info = profile;
1080 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1081 if (net_info == NULL)
1082 return CONNECTION_ERROR_OPERATION_FAILED;
1086 case CONNECTION_PROXY_TYPE_DIRECT:
1087 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
1089 case CONNECTION_PROXY_TYPE_AUTO:
1090 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
1092 case CONNECTION_PROXY_TYPE_MANUAL:
1093 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
1096 return CONNECTION_ERROR_INVALID_PARAMETER;
1100 return CONNECTION_ERROR_NONE;
1103 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
1104 connection_address_family_e address_family, const char* proxy_address)
1106 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1108 CONNECTION_LOG(CONNECTION_ERROR, "Address Family: ", address_family);
1109 if (!(_connection_libnet_check_profile_validity(profile)) ||
1110 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1111 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1112 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1113 return CONNECTION_ERROR_INVALID_PARAMETER;
1116 net_profile_info_t *profile_info = profile;
1117 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1118 if (net_info == NULL)
1119 return CONNECTION_ERROR_OPERATION_FAILED;
1121 if (proxy_address == NULL)
1122 net_info->ProxyAddr[0] = '\0';
1124 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
1126 return CONNECTION_ERROR_NONE;
1129 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
1130 connection_profile_state_changed_cb callback, void* user_data)
1132 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1134 if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
1135 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1136 return CONNECTION_ERROR_INVALID_PARAMETER;
1139 if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
1140 return CONNECTION_ERROR_NONE;
1142 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1145 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
1147 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1149 if (!(_connection_libnet_check_profile_validity(profile))) {
1150 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1151 return CONNECTION_ERROR_INVALID_PARAMETER;
1154 if (_connection_libnet_remove_from_profile_cb_list(profile) != true)
1155 return CONNECTION_ERROR_INVALID_PARAMETER;
1157 return CONNECTION_ERROR_NONE;
1161 /* Wi-Fi profile *************************************************************/
1162 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
1164 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1166 if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
1167 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1168 return CONNECTION_ERROR_INVALID_PARAMETER;
1171 net_profile_info_t *profile_info = profile;
1173 if (profile_info->profile_type != NET_DEVICE_WIFI &&
1174 profile_info->profile_type != NET_DEVICE_MESH)
1175 return CONNECTION_ERROR_INVALID_PARAMETER;
1177 if (profile_info->profile_type == NET_DEVICE_WIFI)
1178 *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
1180 *essid = g_strdup(profile_info->ProfileInfo.Mesh.essid);
1183 return CONNECTION_ERROR_OUT_OF_MEMORY;
1185 return CONNECTION_ERROR_NONE;
1188 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
1190 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1192 if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
1193 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1194 return CONNECTION_ERROR_INVALID_PARAMETER;
1197 net_profile_info_t *profile_info = profile;
1199 if (profile_info->profile_type != NET_DEVICE_WIFI &&
1200 profile_info->profile_type != NET_DEVICE_MESH)
1201 return CONNECTION_ERROR_INVALID_PARAMETER;
1203 if (profile_info->profile_type == NET_DEVICE_WIFI)
1204 *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
1206 *bssid = g_strdup(profile_info->ProfileInfo.Mesh.bssid);
1209 return CONNECTION_ERROR_OUT_OF_MEMORY;
1211 return CONNECTION_ERROR_NONE;
1214 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1216 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1218 if (!(_connection_libnet_check_profile_validity(profile)) || rssi == 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 profile_info->profile_type != NET_DEVICE_MESH)
1227 return CONNECTION_ERROR_INVALID_PARAMETER;
1229 if (profile_info->profile_type == NET_DEVICE_WIFI)
1230 *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1232 *rssi = (int)profile_info->ProfileInfo.Mesh.Strength;
1235 return CONNECTION_ERROR_NONE;
1238 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1240 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1242 if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
1243 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1244 return CONNECTION_ERROR_INVALID_PARAMETER;
1247 net_profile_info_t *profile_info = profile;
1249 if (profile_info->profile_type != NET_DEVICE_WIFI &&
1250 profile_info->profile_type != NET_DEVICE_MESH)
1251 return CONNECTION_ERROR_INVALID_PARAMETER;
1253 if (profile_info->profile_type == NET_DEVICE_WIFI)
1254 *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1256 *frequency = (int)profile_info->ProfileInfo.Mesh.frequency;
1259 return CONNECTION_ERROR_NONE;
1262 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1264 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1266 if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
1267 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1268 return CONNECTION_ERROR_INVALID_PARAMETER;
1271 net_profile_info_t *profile_info = profile;
1273 if (profile_info->profile_type != NET_DEVICE_WIFI)
1274 return CONNECTION_ERROR_INVALID_PARAMETER;
1276 *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate / 1000000;
1278 return CONNECTION_ERROR_NONE;
1281 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e *type)
1283 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1285 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1286 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1287 return CONNECTION_ERROR_INVALID_PARAMETER;
1290 net_profile_info_t *profile_info = profile;
1292 wlan_security_mode_type_t sec_mode;
1293 if (profile_info->profile_type != NET_DEVICE_WIFI &&
1294 profile_info->profile_type != NET_DEVICE_MESH)
1295 return CONNECTION_ERROR_INVALID_PARAMETER;
1297 if (profile_info->profile_type == NET_DEVICE_WIFI)
1298 sec_mode = profile_info->ProfileInfo.Wlan.security_info.sec_mode;
1300 sec_mode = profile_info->ProfileInfo.Mesh.security_info.sec_mode;
1304 case WLAN_SEC_MODE_NONE:
1305 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1307 case WLAN_SEC_MODE_WEP:
1308 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1310 case WLAN_SEC_MODE_IEEE8021X:
1311 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1313 case WLAN_SEC_MODE_WPA_PSK:
1314 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1316 case WLAN_SEC_MODE_WPA2_PSK:
1317 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1319 case WLAN_SEC_MODE_SAE:
1320 *type = CONNECTION_WIFI_SECURITY_TYPE_SAE;
1323 return CONNECTION_ERROR_OPERATION_FAILED;
1327 return CONNECTION_ERROR_NONE;
1330 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e *type)
1332 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1334 if (!(_connection_libnet_check_profile_validity(profile)) || type == 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 switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1346 case WLAN_ENC_MODE_NONE:
1347 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1349 case WLAN_ENC_MODE_WEP:
1350 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1352 case WLAN_ENC_MODE_TKIP:
1353 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1355 case WLAN_ENC_MODE_AES:
1356 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1358 case WLAN_ENC_MODE_TKIP_AES_MIXED:
1359 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1362 return CONNECTION_ERROR_OPERATION_FAILED;
1366 return CONNECTION_ERROR_NONE;
1369 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1371 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1373 if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1374 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1375 return CONNECTION_ERROR_INVALID_PARAMETER;
1378 net_profile_info_t *profile_info = profile;
1380 wlan_security_mode_type_t sec_mode;
1381 if (profile_info->profile_type != NET_DEVICE_WIFI &&
1382 profile_info->profile_type != NET_DEVICE_MESH)
1383 return CONNECTION_ERROR_INVALID_PARAMETER;
1385 if (profile_info->Favourite) {
1387 return CONNECTION_ERROR_NONE;
1390 if (profile_info->profile_type == NET_DEVICE_WIFI)
1391 sec_mode = profile_info->ProfileInfo.Wlan.security_info.sec_mode;
1393 sec_mode = profile_info->ProfileInfo.Mesh.security_info.sec_mode;
1397 case WLAN_SEC_MODE_NONE:
1400 case WLAN_SEC_MODE_WEP:
1401 case WLAN_SEC_MODE_IEEE8021X:
1402 case WLAN_SEC_MODE_WPA_PSK:
1403 case WLAN_SEC_MODE_WPA2_PSK:
1404 case WLAN_SEC_MODE_SAE:
1408 return CONNECTION_ERROR_OPERATION_FAILED;
1412 return CONNECTION_ERROR_NONE;
1415 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1417 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1419 if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1420 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1421 return CONNECTION_ERROR_INVALID_PARAMETER;
1424 net_profile_info_t *profile_info = profile;
1426 if (profile_info->profile_type != NET_DEVICE_WIFI &&
1427 profile_info->profile_type != NET_DEVICE_MESH)
1428 return CONNECTION_ERROR_INVALID_PARAMETER;
1430 if (profile_info->profile_type == NET_DEVICE_WIFI)
1431 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1432 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1434 g_strlcpy(profile_info->ProfileInfo.Mesh.security_info.authentication.sae.saeKey,
1435 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1437 return CONNECTION_ERROR_NONE;
1440 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1442 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1444 if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1445 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1446 return CONNECTION_ERROR_INVALID_PARAMETER;
1449 net_profile_info_t *profile_info = profile;
1451 if (profile_info->profile_type != NET_DEVICE_WIFI)
1452 return CONNECTION_ERROR_INVALID_PARAMETER;
1454 if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1459 return CONNECTION_ERROR_NONE;
1463 /* Cellular profile **********************************************************/
1464 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1465 connection_cellular_service_type_e* type)
1467 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1469 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1470 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1471 return CONNECTION_ERROR_INVALID_PARAMETER;
1474 net_profile_info_t *profile_info = profile;
1476 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1477 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1478 return CONNECTION_ERROR_INVALID_PARAMETER;
1481 *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1483 if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1484 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed"); //LCOV_EXCL_LINE
1485 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1488 return CONNECTION_ERROR_NONE;
1491 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1493 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1495 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1496 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1497 return CONNECTION_ERROR_INVALID_PARAMETER;
1500 net_profile_info_t *profile_info = profile;
1502 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1503 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1504 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1507 *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1509 return CONNECTION_ERROR_OUT_OF_MEMORY;
1511 return CONNECTION_ERROR_NONE;
1514 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1515 connection_cellular_auth_type_e *type, char** user_name, char** password)
1517 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1519 if (!(_connection_libnet_check_profile_validity(profile)) ||
1520 type == NULL || user_name == NULL || password == NULL) {
1521 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1522 return CONNECTION_ERROR_INVALID_PARAMETER;
1525 net_profile_info_t *profile_info = profile;
1527 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1528 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1529 return CONNECTION_ERROR_INVALID_PARAMETER;
1532 switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1534 case NET_PDP_AUTH_NONE:
1535 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1537 case NET_PDP_AUTH_PAP:
1538 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1540 case NET_PDP_AUTH_CHAP:
1541 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1544 return CONNECTION_ERROR_OPERATION_FAILED;
1548 *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1549 if (*user_name == NULL)
1550 return CONNECTION_ERROR_OUT_OF_MEMORY;
1552 *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1553 if (*password == NULL) {
1554 g_free(*user_name); //LCOV_EXCL_LINE
1555 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1558 return CONNECTION_ERROR_NONE;
1561 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1563 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1565 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1566 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1567 return CONNECTION_ERROR_INVALID_PARAMETER;
1570 net_profile_info_t *profile_info = profile;
1572 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1573 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1574 return CONNECTION_ERROR_INVALID_PARAMETER;
1577 *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1578 if (*home_url == NULL)
1579 return CONNECTION_ERROR_OUT_OF_MEMORY;
1581 return CONNECTION_ERROR_NONE;
1584 EXPORT_API int connection_profile_get_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1586 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1588 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1589 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1590 return CONNECTION_ERROR_INVALID_PARAMETER;
1593 net_profile_info_t *profile_info = profile;
1595 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1596 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1597 return CONNECTION_ERROR_INVALID_PARAMETER;
1600 switch (profile_info->ProfileInfo.Pdp.PdnType) {
1602 case NET_PDN_TYPE_UNKNOWN:
1603 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1605 case NET_PDN_TYPE_IPV4:
1606 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1608 case NET_PDN_TYPE_IPV6:
1609 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1611 case NET_PDN_TYPE_IPV4_IPV6:
1612 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1615 return CONNECTION_ERROR_OPERATION_FAILED;
1619 return CONNECTION_ERROR_NONE;
1622 EXPORT_API int connection_profile_get_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1624 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1626 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1627 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1628 return CONNECTION_ERROR_INVALID_PARAMETER;
1631 net_profile_info_t *profile_info = profile;
1633 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1634 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1635 return CONNECTION_ERROR_INVALID_PARAMETER;
1638 switch (profile_info->ProfileInfo.Pdp.RoamPdnType) {
1640 case NET_PDN_TYPE_UNKNOWN:
1641 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1643 case NET_PDN_TYPE_IPV4:
1644 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1646 case NET_PDN_TYPE_IPV6:
1647 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1649 case NET_PDN_TYPE_IPV4_IPV6:
1650 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1653 return CONNECTION_ERROR_OPERATION_FAILED;
1657 return CONNECTION_ERROR_NONE;
1660 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1662 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1664 if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1665 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1666 return CONNECTION_ERROR_INVALID_PARAMETER;
1669 net_profile_info_t *profile_info = profile;
1671 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1672 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1673 return CONNECTION_ERROR_INVALID_PARAMETER;
1676 if (profile_info->ProfileInfo.Pdp.Roaming)
1679 *is_roaming = false;
1681 return CONNECTION_ERROR_NONE;
1684 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
1686 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1688 if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
1689 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1690 return CONNECTION_ERROR_INVALID_PARAMETER;
1693 net_profile_info_t *profile_info = profile;
1695 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1696 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1697 return CONNECTION_ERROR_INVALID_PARAMETER;
1700 if (profile_info->ProfileInfo.Pdp.Hidden)
1705 return CONNECTION_ERROR_NONE;
1708 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
1710 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1712 if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
1713 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1714 return CONNECTION_ERROR_INVALID_PARAMETER;
1717 net_profile_info_t *profile_info = profile;
1719 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1720 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1721 return CONNECTION_ERROR_INVALID_PARAMETER;
1724 if (profile_info->ProfileInfo.Pdp.Editable)
1725 *is_editable = true;
1727 *is_editable = false;
1729 return CONNECTION_ERROR_NONE;
1732 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
1734 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1736 if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
1737 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1738 return CONNECTION_ERROR_INVALID_PARAMETER;
1741 net_profile_info_t *profile_info = profile;
1743 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1744 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1745 return CONNECTION_ERROR_INVALID_PARAMETER;
1748 if (profile_info->ProfileInfo.Pdp.DefaultConn)
1751 *is_default = false;
1753 return CONNECTION_ERROR_NONE;
1756 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
1757 connection_cellular_service_type_e service_type)
1759 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1761 if (!(_connection_libnet_check_profile_validity(profile))) {
1762 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1763 return CONNECTION_ERROR_INVALID_PARAMETER;
1766 net_profile_info_t *profile_info = profile;
1768 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1769 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1770 return CONNECTION_ERROR_INVALID_PARAMETER;
1773 switch (service_type) {
1775 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1776 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1778 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1779 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1781 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1782 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1784 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1785 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1787 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1788 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1790 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1791 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1793 case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1795 return CONNECTION_ERROR_INVALID_PARAMETER;
1799 return CONNECTION_ERROR_NONE;
1802 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1804 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1806 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1807 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1808 return CONNECTION_ERROR_INVALID_PARAMETER;
1811 net_profile_info_t *profile_info = profile;
1813 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1814 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1815 return CONNECTION_ERROR_INVALID_PARAMETER;
1818 g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1820 return CONNECTION_ERROR_NONE;
1823 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1824 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1826 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1828 if (!(_connection_libnet_check_profile_validity(profile)) ||
1829 user_name == NULL || password == NULL) {
1830 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1831 return CONNECTION_ERROR_INVALID_PARAMETER;
1834 net_profile_info_t *profile_info = profile;
1836 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1837 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1838 return CONNECTION_ERROR_INVALID_PARAMETER;
1843 case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1844 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1846 case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1847 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1849 case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1850 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1853 return CONNECTION_ERROR_INVALID_PARAMETER;
1857 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1858 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1860 return CONNECTION_ERROR_NONE;
1863 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1865 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1867 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1868 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1869 return CONNECTION_ERROR_INVALID_PARAMETER;
1872 net_profile_info_t *profile_info = profile;
1874 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1875 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1876 return CONNECTION_ERROR_INVALID_PARAMETER;
1879 g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1881 return CONNECTION_ERROR_NONE;
1884 EXPORT_API int connection_profile_set_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
1886 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1888 if (!(_connection_libnet_check_profile_validity(profile))) {
1889 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1890 return CONNECTION_ERROR_INVALID_PARAMETER;
1893 net_profile_info_t *profile_info = profile;
1895 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1896 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1897 return CONNECTION_ERROR_INVALID_PARAMETER;
1902 case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
1903 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4;
1905 case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
1906 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV6;
1908 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
1909 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
1910 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
1911 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
1913 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
1914 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
1917 return CONNECTION_ERROR_INVALID_PARAMETER;
1921 return CONNECTION_ERROR_NONE;
1924 EXPORT_API int connection_profile_set_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
1926 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1928 if (!(_connection_libnet_check_profile_validity(profile))) {
1929 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1930 return CONNECTION_ERROR_INVALID_PARAMETER;
1933 net_profile_info_t *profile_info = profile;
1935 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1936 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1937 return CONNECTION_ERROR_INVALID_PARAMETER;
1942 case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
1943 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4;
1945 case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
1946 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV6;
1948 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
1949 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
1950 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
1951 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
1953 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
1954 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
1957 return CONNECTION_ERROR_INVALID_PARAMETER;
1961 return CONNECTION_ERROR_NONE;
1964 EXPORT_API int connection_profile_get_ipv6_state(connection_profile_h profile, connection_profile_state_e *state)
1966 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1967 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1969 if (!(_connection_libnet_check_profile_validity(profile)) ||
1971 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1972 return CONNECTION_ERROR_INVALID_PARAMETER;
1975 net_profile_info_t *profile_info = profile;
1976 *state = _profile_convert_to_cp_state(profile_info->ProfileState6);
1978 return CONNECTION_ERROR_OPERATION_FAILED;
1980 return CONNECTION_ERROR_NONE;
1983 EXPORT_API int connection_profile_set_dns_config_type(connection_profile_h profile,
1984 connection_address_family_e address_family, connection_dns_config_type_e type)
1986 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1987 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1989 if (!(_connection_libnet_check_profile_validity(profile))) {
1990 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1991 return CONNECTION_ERROR_INVALID_PARAMETER;
1994 if ((address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1995 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1996 (type != CONNECTION_DNS_CONFIG_TYPE_STATIC &&
1997 type != CONNECTION_DNS_CONFIG_TYPE_DYNAMIC)) {
1998 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1999 return CONNECTION_ERROR_INVALID_PARAMETER;
2002 net_dns_config_type_t *profileType = NULL;
2003 net_dns_config_type_t *profileType6 = NULL;
2004 net_profile_info_t *profile_info = profile;
2006 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2007 if (net_info == NULL)
2008 return CONNECTION_ERROR_OPERATION_FAILED;
2010 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
2011 profileType = &net_info->DnsConfigType;
2012 net_info->DnsAddr[0].Data.Ipv4.s_addr = 0;
2013 net_info->DnsAddr[1].Data.Ipv4.s_addr = 0;
2014 *profileType = type;
2016 profileType6 = &net_info->DnsConfigType6;
2017 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[0].Data.Ipv6);
2018 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[1].Data.Ipv6);
2019 *profileType6 = type;
2022 return CONNECTION_ERROR_NONE;
2025 EXPORT_API int connection_profile_get_dns_config_type(connection_profile_h profile,
2026 connection_address_family_e address_family, connection_dns_config_type_e *type)
2028 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2029 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2031 if (!(_connection_libnet_check_profile_validity(profile)) ||
2032 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2033 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2035 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2036 return CONNECTION_ERROR_INVALID_PARAMETER;
2039 net_dns_config_type_t profileType;
2040 net_profile_info_t *profile_info = profile;
2041 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2042 if (net_info == NULL)
2043 return CONNECTION_ERROR_OPERATION_FAILED;
2045 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
2046 profileType = net_info->DnsConfigType;
2048 profileType = net_info->DnsConfigType6;
2050 switch (profileType) {
2051 case NET_DNS_CONFIG_TYPE_STATIC:
2052 *type = CONNECTION_DNS_CONFIG_TYPE_STATIC;
2054 case NET_DNS_CONFIG_TYPE_DYNAMIC:
2055 *type = CONNECTION_DNS_CONFIG_TYPE_DYNAMIC;
2058 *type = CONNECTION_DNS_CONFIG_TYPE_NONE;
2062 return CONNECTION_ERROR_NONE;
2065 EXPORT_API int connection_profile_set_prefix_length(connection_profile_h profile,
2066 connection_address_family_e address_family, int prefix_len)
2068 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2069 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2071 if (!(_connection_libnet_check_profile_validity(profile)) ||
2072 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2073 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
2074 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2075 return CONNECTION_ERROR_INVALID_PARAMETER;
2078 net_profile_info_t *profile_info = profile;
2079 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2080 if (net_info == NULL)
2081 return CONNECTION_ERROR_OPERATION_FAILED;
2083 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
2084 net_info->PrefixLen = prefix_len;
2085 net_info->SubnetMask.Data.Ipv4.s_addr = __profile_convert_prefix_len_to_netmask(prefix_len);
2087 net_info->PrefixLen6 = prefix_len;
2089 return CONNECTION_ERROR_NONE;
2092 EXPORT_API int connection_profile_get_prefix_length(connection_profile_h profile,
2093 connection_address_family_e address_family, int *prefix_len)
2095 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2096 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2098 if (!(_connection_libnet_check_profile_validity(profile)) ||
2099 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2100 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2101 prefix_len == NULL) {
2102 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2103 return CONNECTION_ERROR_INVALID_PARAMETER;
2106 net_profile_info_t *profile_info = profile;
2107 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2108 if (net_info == NULL)
2109 return CONNECTION_ERROR_OPERATION_FAILED;
2111 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
2112 *prefix_len = net_info->PrefixLen;
2113 else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
2114 *prefix_len = net_info->PrefixLen6;
2116 return CONNECTION_ERROR_NONE;