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 int __profile_convert_netmask_to_prefix_len(const char *netmask)
129 in_addr_t mask = inet_network(netmask);
132 for (; mask; mask <<= 1)
138 static in_addr_t __profile_convert_prefix_len_to_netmask(int prefix_len)
140 return (prefix_len ? (in_addr_t) 0xFFFFFFFFu >> (32 - prefix_len) : 0);
144 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
147 case NET_SERVICE_INTERNET:
148 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
149 case NET_SERVICE_MMS:
150 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
151 case NET_SERVICE_PREPAID_INTERNET:
152 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
153 case NET_SERVICE_PREPAID_MMS:
154 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
155 case NET_SERVICE_TETHERING:
156 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
157 case NET_SERVICE_APPLICATION:
158 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
160 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
164 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
166 connection_profile_state_e cp_state;
169 case NET_STATE_TYPE_ONLINE:
170 case NET_STATE_TYPE_READY:
171 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
173 case NET_STATE_TYPE_IDLE:
174 case NET_STATE_TYPE_FAILURE:
175 case NET_STATE_TYPE_DISCONNECT:
176 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
178 case NET_STATE_TYPE_ASSOCIATION:
179 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
181 case NET_STATE_TYPE_CONFIGURATION:
182 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
191 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
194 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
195 return NET_SERVICE_INTERNET;
196 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
197 return NET_SERVICE_MMS;
198 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
199 return NET_SERVICE_PREPAID_INTERNET;
200 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
201 return NET_SERVICE_PREPAID_MMS;
202 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
203 return NET_SERVICE_TETHERING;
204 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
205 return NET_SERVICE_APPLICATION;
207 return NET_SERVICE_UNKNOWN;
211 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
213 net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
216 case CONNECTION_PROFILE_STATE_CONNECTED:
217 libnet_state = NET_STATE_TYPE_ONLINE;
219 case CONNECTION_PROFILE_STATE_DISCONNECTED:
220 libnet_state = NET_STATE_TYPE_IDLE;
222 case CONNECTION_PROFILE_STATE_ASSOCIATION:
223 libnet_state = NET_STATE_TYPE_ASSOCIATION;
225 case CONNECTION_PROFILE_STATE_CONFIGURATION:
226 libnet_state = NET_STATE_TYPE_CONFIGURATION;
234 /* Connection profile ********************************************************/
235 EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
237 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
239 if (type == CONNECTION_PROFILE_TYPE_CELLULAR)
240 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
241 else if (type == CONNECTION_PROFILE_TYPE_WIFI)
242 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
244 if (type != CONNECTION_PROFILE_TYPE_CELLULAR &&
245 type != CONNECTION_PROFILE_TYPE_WIFI) {
246 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
247 return CONNECTION_ERROR_INVALID_PARAMETER;
250 if (profile == NULL) {
251 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
252 return CONNECTION_ERROR_INVALID_PARAMETER;
255 int rv = _connection_libnet_check_profile_privilege();
256 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
258 else if (rv != CONNECTION_ERROR_NONE) {
259 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create profile"); //LCOV_EXCL_LINE
260 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
263 net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
264 if (profile_info == NULL)
265 return CONNECTION_ERROR_OUT_OF_MEMORY;
268 case CONNECTION_PROFILE_TYPE_CELLULAR:
269 if (keyword == NULL) {
270 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
271 g_free(profile_info);
272 return CONNECTION_ERROR_INVALID_PARAMETER;
274 __profile_init_cellular_profile(profile_info, keyword);
276 case CONNECTION_PROFILE_TYPE_WIFI:
277 __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 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
696 return CONNECTION_ERROR_INVALID_PARAMETER;
699 net_profile_info_t *profile_info = profile;
700 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
701 if (net_info == NULL)
702 return CONNECTION_ERROR_OPERATION_FAILED;
704 CONNECTION_LOG(CONNECTION_INFO, "Lease duration : %d",
705 net_info->DHCPLeaseDuration);
707 *dhcp_lease_duration = net_info->DHCPLeaseDuration;
709 return CONNECTION_ERROR_NONE;
712 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
713 connection_address_family_e address_family, char** dns_address)
715 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
717 if (!(_connection_libnet_check_profile_validity(profile)) ||
718 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
719 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
720 dns_address == NULL ||
722 order > NET_DNS_ADDR_MAX) {
723 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
724 return CONNECTION_ERROR_INVALID_PARAMETER;
727 net_profile_info_t *profile_info = profile;
728 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
729 if (net_info == NULL)
730 return CONNECTION_ERROR_OPERATION_FAILED;
732 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
733 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
735 else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) //LCOV_EXCL_LINE
736 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1], //LCOV_EXCL_LINE
739 if (*dns_address == NULL)
740 return CONNECTION_ERROR_OUT_OF_MEMORY;
742 return CONNECTION_ERROR_NONE;
745 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e *type)
747 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
749 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
750 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
751 return CONNECTION_ERROR_INVALID_PARAMETER;
754 net_profile_info_t *profile_info = profile;
755 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
756 if (net_info == NULL)
757 return CONNECTION_ERROR_OPERATION_FAILED;
760 if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
761 char *proxy = __profile_get_ethernet_proxy();
763 *type = CONNECTION_PROXY_TYPE_DIRECT;
765 *type = CONNECTION_PROXY_TYPE_MANUAL;
769 return CONNECTION_ERROR_NONE;
773 switch (net_info->ProxyMethod) {
775 case NET_PROXY_TYPE_DIRECT:
776 *type = CONNECTION_PROXY_TYPE_DIRECT;
778 case NET_PROXY_TYPE_AUTO:
779 *type = CONNECTION_PROXY_TYPE_AUTO;
781 case NET_PROXY_TYPE_MANUAL:
782 *type = CONNECTION_PROXY_TYPE_MANUAL;
784 case NET_PROXY_TYPE_UNKNOWN:
786 return CONNECTION_ERROR_OPERATION_FAILED;
790 return CONNECTION_ERROR_NONE;
793 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
794 connection_address_family_e address_family, char** proxy_address)
796 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
798 if (!(_connection_libnet_check_profile_validity(profile)) ||
799 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
800 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
801 proxy_address == NULL) {
802 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
803 return CONNECTION_ERROR_INVALID_PARAMETER;
806 net_profile_info_t *profile_info = profile;
807 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
808 if (net_info == NULL)
809 return CONNECTION_ERROR_OPERATION_FAILED;
811 *proxy_address = g_strdup(net_info->ProxyAddr);
813 if (*proxy_address == NULL)
814 return CONNECTION_ERROR_OUT_OF_MEMORY;
816 return CONNECTION_ERROR_NONE;
819 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
820 connection_address_family_e address_family, connection_ip_config_type_e type)
822 net_ip_config_type_t *profile_type = NULL;
824 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
826 if (!(_connection_libnet_check_profile_validity(profile)) ||
827 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
828 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
829 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
830 return CONNECTION_ERROR_INVALID_PARAMETER;
833 net_profile_info_t *profile_info = profile;
834 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
835 if (net_info == NULL)
836 return CONNECTION_ERROR_OPERATION_FAILED;
838 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
839 profile_type = &net_info->IpConfigType ;
841 profile_type = &net_info->IpConfigType6 ;
843 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
846 case CONNECTION_IP_CONFIG_TYPE_STATIC:
847 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
848 net_info->IpAddr.Data.Ipv4.s_addr = 0;
849 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
850 net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
853 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
854 *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
857 case CONNECTION_IP_CONFIG_TYPE_AUTO:
858 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
861 case CONNECTION_IP_CONFIG_TYPE_FIXED:
862 net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
865 case CONNECTION_IP_CONFIG_TYPE_NONE:
866 *profile_type = NET_IP_CONFIG_TYPE_OFF;
870 return CONNECTION_ERROR_INVALID_PARAMETER;
876 case CONNECTION_IP_CONFIG_TYPE_STATIC:
877 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
878 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
879 net_info->PrefixLen6 = 0 ;
880 inet_pton(AF_INET6, "::",
881 &net_info->GatewayAddr6.Data.Ipv6);
884 case CONNECTION_IP_CONFIG_TYPE_AUTO:
885 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
888 case CONNECTION_IP_CONFIG_TYPE_NONE:
889 *profile_type = NET_IP_CONFIG_TYPE_OFF;
893 return CONNECTION_ERROR_INVALID_PARAMETER;
898 return CONNECTION_ERROR_NONE;
901 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
902 connection_address_family_e address_family, const char* ip_address)
904 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
906 if (!(_connection_libnet_check_profile_validity(profile)) ||
907 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
908 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
909 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
910 return CONNECTION_ERROR_INVALID_PARAMETER;
913 net_profile_info_t *profile_info = profile;
914 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
915 if (net_info == NULL)
916 return CONNECTION_ERROR_OPERATION_FAILED;
918 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
920 if (ip_address == NULL)
921 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
922 else if (inet_pton(AF_INET6, ip_address,
923 &net_info->IpAddr6.Data.Ipv6) < 1)
924 return CONNECTION_ERROR_INVALID_PARAMETER;
927 if (ip_address == NULL)
928 net_info->IpAddr.Data.Ipv4.s_addr = 0;
929 else if (inet_pton(AF_INET, ip_address,
930 &net_info->IpAddr.Data.Ipv4) < 1)
931 return CONNECTION_ERROR_INVALID_PARAMETER;
934 return CONNECTION_ERROR_NONE;
937 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
938 connection_address_family_e address_family, const char* subnet_mask)
940 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
942 if (!(_connection_libnet_check_profile_validity(profile)) ||
943 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
944 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
945 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
946 return CONNECTION_ERROR_INVALID_PARAMETER;
949 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
950 CONNECTION_LOG(CONNECTION_ERROR,
951 "Please uses connection_profile_set_prefix_length()");
952 return CONNECTION_ERROR_NOT_SUPPORTED;
955 net_profile_info_t *profile_info = profile;
956 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
957 if (net_info == NULL)
958 return CONNECTION_ERROR_OPERATION_FAILED;
960 if (subnet_mask == NULL)
961 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
962 else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4) < 1)
963 return CONNECTION_ERROR_INVALID_PARAMETER;
965 net_info->PrefixLen = __profile_convert_netmask_to_prefix_len(subnet_mask);
967 return CONNECTION_ERROR_NONE;
970 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
971 connection_address_family_e address_family, const char* gateway_address)
973 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
975 if (!(_connection_libnet_check_profile_validity(profile)) ||
976 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
977 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
978 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
979 return CONNECTION_ERROR_INVALID_PARAMETER;
982 net_profile_info_t *profile_info = profile;
983 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
984 if (net_info == NULL)
985 return CONNECTION_ERROR_OPERATION_FAILED;
987 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
989 if (gateway_address == NULL)
990 inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
991 else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1)
992 return CONNECTION_ERROR_INVALID_PARAMETER;
995 if (gateway_address == NULL)
996 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
997 else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1)
998 return CONNECTION_ERROR_INVALID_PARAMETER;
1001 return CONNECTION_ERROR_NONE;
1004 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
1005 connection_address_family_e address_family, const char* dns_address)
1007 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1009 if (!(_connection_libnet_check_profile_validity(profile)) ||
1010 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1011 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1013 order > NET_DNS_ADDR_MAX) {
1014 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1015 return CONNECTION_ERROR_INVALID_PARAMETER;
1018 net_profile_info_t *profile_info = profile;
1019 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1020 if (net_info == NULL)
1021 return CONNECTION_ERROR_OPERATION_FAILED;
1023 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1025 net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
1026 if (dns_address == NULL)
1027 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
1028 else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1)
1029 return CONNECTION_ERROR_INVALID_PARAMETER;
1030 if (net_info->DnsCount6 < order)
1031 net_info->DnsCount6 = order;
1034 net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
1035 if (dns_address == NULL)
1036 net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
1037 else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1)
1038 return CONNECTION_ERROR_INVALID_PARAMETER;
1039 if (net_info->DnsCount < order)
1040 net_info->DnsCount = order;
1043 return CONNECTION_ERROR_NONE;
1046 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
1048 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1050 if (!(_connection_libnet_check_profile_validity(profile))) {
1051 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1052 return CONNECTION_ERROR_INVALID_PARAMETER;
1055 net_profile_info_t *profile_info = profile;
1056 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1057 if (net_info == NULL)
1058 return CONNECTION_ERROR_OPERATION_FAILED;
1062 case CONNECTION_PROXY_TYPE_DIRECT:
1063 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
1065 case CONNECTION_PROXY_TYPE_AUTO:
1066 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
1068 case CONNECTION_PROXY_TYPE_MANUAL:
1069 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
1072 return CONNECTION_ERROR_INVALID_PARAMETER;
1076 return CONNECTION_ERROR_NONE;
1079 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
1080 connection_address_family_e address_family, const char* proxy_address)
1082 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1084 CONNECTION_LOG(CONNECTION_ERROR, "Address Family: ", address_family);
1085 if (!(_connection_libnet_check_profile_validity(profile)) ||
1086 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1087 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1088 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1089 return CONNECTION_ERROR_INVALID_PARAMETER;
1092 net_profile_info_t *profile_info = profile;
1093 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1094 if (net_info == NULL)
1095 return CONNECTION_ERROR_OPERATION_FAILED;
1097 if (proxy_address == NULL)
1098 net_info->ProxyAddr[0] = '\0';
1100 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
1102 return CONNECTION_ERROR_NONE;
1105 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
1106 connection_profile_state_changed_cb callback, void* user_data)
1108 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1110 if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
1111 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1112 return CONNECTION_ERROR_INVALID_PARAMETER;
1115 if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
1116 return CONNECTION_ERROR_NONE;
1118 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1121 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
1123 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1125 if (!(_connection_libnet_check_profile_validity(profile))) {
1126 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1127 return CONNECTION_ERROR_INVALID_PARAMETER;
1130 if (_connection_libnet_remove_from_profile_cb_list(profile) != true)
1131 return CONNECTION_ERROR_INVALID_PARAMETER;
1133 return CONNECTION_ERROR_NONE;
1137 /* Wi-Fi profile *************************************************************/
1138 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
1140 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1142 if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
1143 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1144 return CONNECTION_ERROR_INVALID_PARAMETER;
1147 net_profile_info_t *profile_info = profile;
1149 if (profile_info->profile_type != NET_DEVICE_WIFI)
1150 return CONNECTION_ERROR_INVALID_PARAMETER;
1152 *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
1154 return CONNECTION_ERROR_OUT_OF_MEMORY;
1156 return CONNECTION_ERROR_NONE;
1159 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
1161 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1163 if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
1164 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1165 return CONNECTION_ERROR_INVALID_PARAMETER;
1168 net_profile_info_t *profile_info = profile;
1170 if (profile_info->profile_type != NET_DEVICE_WIFI)
1171 return CONNECTION_ERROR_INVALID_PARAMETER;
1173 *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
1175 return CONNECTION_ERROR_OUT_OF_MEMORY;
1177 return CONNECTION_ERROR_NONE;
1180 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1182 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1184 if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
1185 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1186 return CONNECTION_ERROR_INVALID_PARAMETER;
1189 net_profile_info_t *profile_info = profile;
1191 if (profile_info->profile_type != NET_DEVICE_WIFI)
1192 return CONNECTION_ERROR_INVALID_PARAMETER;
1194 *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1196 return CONNECTION_ERROR_NONE;
1199 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1201 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1203 if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
1204 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1205 return CONNECTION_ERROR_INVALID_PARAMETER;
1208 net_profile_info_t *profile_info = profile;
1210 if (profile_info->profile_type != NET_DEVICE_WIFI)
1211 return CONNECTION_ERROR_INVALID_PARAMETER;
1213 *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1215 return CONNECTION_ERROR_NONE;
1218 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1220 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1222 if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
1223 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1224 return CONNECTION_ERROR_INVALID_PARAMETER;
1227 net_profile_info_t *profile_info = profile;
1229 if (profile_info->profile_type != NET_DEVICE_WIFI)
1230 return CONNECTION_ERROR_INVALID_PARAMETER;
1232 *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate / 1000000;
1234 return CONNECTION_ERROR_NONE;
1237 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e *type)
1239 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1241 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1242 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1243 return CONNECTION_ERROR_INVALID_PARAMETER;
1246 net_profile_info_t *profile_info = profile;
1248 if (profile_info->profile_type != NET_DEVICE_WIFI)
1249 return CONNECTION_ERROR_INVALID_PARAMETER;
1251 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1253 case WLAN_SEC_MODE_NONE:
1254 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1256 case WLAN_SEC_MODE_WEP:
1257 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1259 case WLAN_SEC_MODE_IEEE8021X:
1260 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1262 case WLAN_SEC_MODE_WPA_PSK:
1263 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1265 case WLAN_SEC_MODE_WPA2_PSK:
1266 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1269 return CONNECTION_ERROR_OPERATION_FAILED;
1273 return CONNECTION_ERROR_NONE;
1276 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e *type)
1278 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1280 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1281 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1282 return CONNECTION_ERROR_INVALID_PARAMETER;
1285 net_profile_info_t *profile_info = profile;
1287 if (profile_info->profile_type != NET_DEVICE_WIFI)
1288 return CONNECTION_ERROR_INVALID_PARAMETER;
1290 switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1292 case WLAN_ENC_MODE_NONE:
1293 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1295 case WLAN_ENC_MODE_WEP:
1296 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1298 case WLAN_ENC_MODE_TKIP:
1299 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1301 case WLAN_ENC_MODE_AES:
1302 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1304 case WLAN_ENC_MODE_TKIP_AES_MIXED:
1305 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1308 return CONNECTION_ERROR_OPERATION_FAILED;
1312 return CONNECTION_ERROR_NONE;
1315 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1317 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1319 if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1320 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1321 return CONNECTION_ERROR_INVALID_PARAMETER;
1324 net_profile_info_t *profile_info = profile;
1326 if (profile_info->profile_type != NET_DEVICE_WIFI)
1327 return CONNECTION_ERROR_INVALID_PARAMETER;
1329 if (profile_info->Favourite) {
1331 return CONNECTION_ERROR_NONE;
1334 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1336 case WLAN_SEC_MODE_NONE:
1339 case WLAN_SEC_MODE_WEP:
1340 case WLAN_SEC_MODE_IEEE8021X:
1341 case WLAN_SEC_MODE_WPA_PSK:
1342 case WLAN_SEC_MODE_WPA2_PSK:
1346 return CONNECTION_ERROR_OPERATION_FAILED;
1350 return CONNECTION_ERROR_NONE;
1353 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1355 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1357 if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1358 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1359 return CONNECTION_ERROR_INVALID_PARAMETER;
1362 net_profile_info_t *profile_info = profile;
1364 if (profile_info->profile_type != NET_DEVICE_WIFI)
1365 return CONNECTION_ERROR_INVALID_PARAMETER;
1367 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1368 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1370 return CONNECTION_ERROR_NONE;
1373 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1375 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1377 if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1378 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1379 return CONNECTION_ERROR_INVALID_PARAMETER;
1382 net_profile_info_t *profile_info = profile;
1384 if (profile_info->profile_type != NET_DEVICE_WIFI)
1385 return CONNECTION_ERROR_INVALID_PARAMETER;
1387 if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1392 return CONNECTION_ERROR_NONE;
1396 /* Cellular profile **********************************************************/
1397 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1398 connection_cellular_service_type_e* type)
1400 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1402 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1403 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1404 return CONNECTION_ERROR_INVALID_PARAMETER;
1407 net_profile_info_t *profile_info = profile;
1409 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1410 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1411 return CONNECTION_ERROR_INVALID_PARAMETER;
1414 *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1416 if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1417 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed"); //LCOV_EXCL_LINE
1418 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1421 return CONNECTION_ERROR_NONE;
1424 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1426 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1428 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1429 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1430 return CONNECTION_ERROR_INVALID_PARAMETER;
1433 net_profile_info_t *profile_info = profile;
1435 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1436 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1437 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1440 *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1442 return CONNECTION_ERROR_OUT_OF_MEMORY;
1444 return CONNECTION_ERROR_NONE;
1447 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1448 connection_cellular_auth_type_e *type, char** user_name, char** password)
1450 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1452 if (!(_connection_libnet_check_profile_validity(profile)) ||
1453 type == NULL || user_name == NULL || password == NULL) {
1454 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1455 return CONNECTION_ERROR_INVALID_PARAMETER;
1458 net_profile_info_t *profile_info = profile;
1460 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1461 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1462 return CONNECTION_ERROR_INVALID_PARAMETER;
1465 switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1467 case NET_PDP_AUTH_NONE:
1468 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1470 case NET_PDP_AUTH_PAP:
1471 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1473 case NET_PDP_AUTH_CHAP:
1474 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1477 return CONNECTION_ERROR_OPERATION_FAILED;
1481 *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1482 if (*user_name == NULL)
1483 return CONNECTION_ERROR_OUT_OF_MEMORY;
1485 *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1486 if (*password == NULL) {
1487 g_free(*user_name); //LCOV_EXCL_LINE
1488 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1491 return CONNECTION_ERROR_NONE;
1494 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1496 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1498 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1499 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1500 return CONNECTION_ERROR_INVALID_PARAMETER;
1503 net_profile_info_t *profile_info = profile;
1505 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1506 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1507 return CONNECTION_ERROR_INVALID_PARAMETER;
1510 *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1511 if (*home_url == NULL)
1512 return CONNECTION_ERROR_OUT_OF_MEMORY;
1514 return CONNECTION_ERROR_NONE;
1517 EXPORT_API int connection_profile_get_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1519 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1521 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1522 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1523 return CONNECTION_ERROR_INVALID_PARAMETER;
1526 net_profile_info_t *profile_info = profile;
1528 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1529 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1530 return CONNECTION_ERROR_INVALID_PARAMETER;
1533 switch (profile_info->ProfileInfo.Pdp.PdnType) {
1535 case NET_PDN_TYPE_UNKNOWN:
1536 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1538 case NET_PDN_TYPE_IPV4:
1539 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1541 case NET_PDN_TYPE_IPV6:
1542 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1544 case NET_PDN_TYPE_IPV4_IPV6:
1545 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1548 return CONNECTION_ERROR_OPERATION_FAILED;
1552 return CONNECTION_ERROR_NONE;
1555 EXPORT_API int connection_profile_get_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1557 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1559 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1560 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1561 return CONNECTION_ERROR_INVALID_PARAMETER;
1564 net_profile_info_t *profile_info = profile;
1566 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1567 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1568 return CONNECTION_ERROR_INVALID_PARAMETER;
1571 switch (profile_info->ProfileInfo.Pdp.RoamPdnType) {
1573 case NET_PDN_TYPE_UNKNOWN:
1574 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1576 case NET_PDN_TYPE_IPV4:
1577 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1579 case NET_PDN_TYPE_IPV6:
1580 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1582 case NET_PDN_TYPE_IPV4_IPV6:
1583 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1586 return CONNECTION_ERROR_OPERATION_FAILED;
1590 return CONNECTION_ERROR_NONE;
1593 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1595 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1597 if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1598 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1599 return CONNECTION_ERROR_INVALID_PARAMETER;
1602 net_profile_info_t *profile_info = profile;
1604 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1605 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1606 return CONNECTION_ERROR_INVALID_PARAMETER;
1609 if (profile_info->ProfileInfo.Pdp.Roaming)
1612 *is_roaming = false;
1614 return CONNECTION_ERROR_NONE;
1617 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
1619 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1621 if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
1622 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1623 return CONNECTION_ERROR_INVALID_PARAMETER;
1626 net_profile_info_t *profile_info = profile;
1628 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1629 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1630 return CONNECTION_ERROR_INVALID_PARAMETER;
1633 if (profile_info->ProfileInfo.Pdp.Hidden)
1638 return CONNECTION_ERROR_NONE;
1641 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
1643 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1645 if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
1646 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1647 return CONNECTION_ERROR_INVALID_PARAMETER;
1650 net_profile_info_t *profile_info = profile;
1652 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1653 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1654 return CONNECTION_ERROR_INVALID_PARAMETER;
1657 if (profile_info->ProfileInfo.Pdp.Editable)
1658 *is_editable = true;
1660 *is_editable = false;
1662 return CONNECTION_ERROR_NONE;
1665 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
1667 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1669 if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
1670 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1671 return CONNECTION_ERROR_INVALID_PARAMETER;
1674 net_profile_info_t *profile_info = profile;
1676 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1677 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1678 return CONNECTION_ERROR_INVALID_PARAMETER;
1681 if (profile_info->ProfileInfo.Pdp.DefaultConn)
1684 *is_default = false;
1686 return CONNECTION_ERROR_NONE;
1689 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
1690 connection_cellular_service_type_e service_type)
1692 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1694 if (!(_connection_libnet_check_profile_validity(profile))) {
1695 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1696 return CONNECTION_ERROR_INVALID_PARAMETER;
1699 net_profile_info_t *profile_info = profile;
1701 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1702 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1703 return CONNECTION_ERROR_INVALID_PARAMETER;
1706 switch (service_type) {
1708 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1709 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1711 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1712 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1714 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1715 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1717 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1718 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1720 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1721 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1723 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1724 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1726 case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1728 return CONNECTION_ERROR_INVALID_PARAMETER;
1732 return CONNECTION_ERROR_NONE;
1735 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1737 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1739 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1740 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1741 return CONNECTION_ERROR_INVALID_PARAMETER;
1744 net_profile_info_t *profile_info = profile;
1746 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1747 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1748 return CONNECTION_ERROR_INVALID_PARAMETER;
1751 g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1753 return CONNECTION_ERROR_NONE;
1756 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1757 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1759 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1761 if (!(_connection_libnet_check_profile_validity(profile)) ||
1762 user_name == NULL || password == NULL) {
1763 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1764 return CONNECTION_ERROR_INVALID_PARAMETER;
1767 net_profile_info_t *profile_info = profile;
1769 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1770 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1771 return CONNECTION_ERROR_INVALID_PARAMETER;
1776 case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1777 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1779 case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1780 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1782 case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1783 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1786 return CONNECTION_ERROR_INVALID_PARAMETER;
1790 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1791 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1793 return CONNECTION_ERROR_NONE;
1796 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1798 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1800 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1801 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1802 return CONNECTION_ERROR_INVALID_PARAMETER;
1805 net_profile_info_t *profile_info = profile;
1807 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1808 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1809 return CONNECTION_ERROR_INVALID_PARAMETER;
1812 g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1814 return CONNECTION_ERROR_NONE;
1817 EXPORT_API int connection_profile_set_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
1819 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1821 if (!(_connection_libnet_check_profile_validity(profile))) {
1822 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1823 return CONNECTION_ERROR_INVALID_PARAMETER;
1826 net_profile_info_t *profile_info = profile;
1828 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1829 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1830 return CONNECTION_ERROR_INVALID_PARAMETER;
1835 case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
1836 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4;
1838 case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
1839 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV6;
1841 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
1842 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
1843 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
1844 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
1846 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
1847 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
1850 return CONNECTION_ERROR_INVALID_PARAMETER;
1854 return CONNECTION_ERROR_NONE;
1857 EXPORT_API int connection_profile_set_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
1859 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1861 if (!(_connection_libnet_check_profile_validity(profile))) {
1862 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1863 return CONNECTION_ERROR_INVALID_PARAMETER;
1866 net_profile_info_t *profile_info = profile;
1868 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1869 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1870 return CONNECTION_ERROR_INVALID_PARAMETER;
1875 case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
1876 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4;
1878 case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
1879 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV6;
1881 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
1882 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
1883 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
1884 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
1886 case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
1887 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
1890 return CONNECTION_ERROR_INVALID_PARAMETER;
1894 return CONNECTION_ERROR_NONE;
1897 EXPORT_API int connection_profile_get_ipv6_state(connection_profile_h profile, connection_profile_state_e *state)
1899 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1900 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1902 if (!(_connection_libnet_check_profile_validity(profile)) ||
1904 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1905 return CONNECTION_ERROR_INVALID_PARAMETER;
1908 net_profile_info_t *profile_info = profile;
1909 *state = _profile_convert_to_cp_state(profile_info->ProfileState6);
1911 return CONNECTION_ERROR_OPERATION_FAILED;
1913 return CONNECTION_ERROR_NONE;
1916 EXPORT_API int connection_profile_set_dns_config_type(connection_profile_h profile,
1917 connection_address_family_e address_family, connection_dns_config_type_e type)
1919 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1920 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1922 if (!(_connection_libnet_check_profile_validity(profile))) {
1923 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1924 return CONNECTION_ERROR_INVALID_PARAMETER;
1927 if ((address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1928 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1929 (type != CONNECTION_DNS_CONFIG_TYPE_STATIC &&
1930 type != CONNECTION_DNS_CONFIG_TYPE_DYNAMIC)) {
1931 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1932 return CONNECTION_ERROR_INVALID_PARAMETER;
1935 net_dns_config_type_t *profileType = NULL;
1936 net_dns_config_type_t *profileType6 = NULL;
1937 net_profile_info_t *profile_info = profile;
1939 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1940 if (net_info == NULL)
1941 return CONNECTION_ERROR_OPERATION_FAILED;
1943 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1944 profileType = &net_info->DnsConfigType;
1945 net_info->DnsAddr[0].Data.Ipv4.s_addr = 0;
1946 net_info->DnsAddr[1].Data.Ipv4.s_addr = 0;
1947 *profileType = type;
1949 profileType6 = &net_info->DnsConfigType6;
1950 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[0].Data.Ipv6);
1951 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[1].Data.Ipv6);
1952 *profileType6 = type;
1955 return CONNECTION_ERROR_NONE;
1958 EXPORT_API int connection_profile_get_dns_config_type(connection_profile_h profile,
1959 connection_address_family_e address_family, connection_dns_config_type_e *type)
1961 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1962 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1964 if (!(_connection_libnet_check_profile_validity(profile)) ||
1965 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1966 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1968 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1969 return CONNECTION_ERROR_INVALID_PARAMETER;
1972 net_dns_config_type_t profileType;
1973 net_profile_info_t *profile_info = profile;
1974 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1975 if (net_info == NULL)
1976 return CONNECTION_ERROR_OPERATION_FAILED;
1978 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
1979 profileType = net_info->DnsConfigType;
1981 profileType = net_info->DnsConfigType6;
1983 switch (profileType) {
1984 case NET_DNS_CONFIG_TYPE_STATIC:
1985 *type = CONNECTION_DNS_CONFIG_TYPE_STATIC;
1987 case NET_DNS_CONFIG_TYPE_DYNAMIC:
1988 *type = CONNECTION_DNS_CONFIG_TYPE_DYNAMIC;
1991 *type = CONNECTION_DNS_CONFIG_TYPE_NONE;
1995 return CONNECTION_ERROR_NONE;
1998 EXPORT_API int connection_profile_set_prefix_length(connection_profile_h profile,
1999 connection_address_family_e address_family, int prefix_len)
2001 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2002 TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2004 if (!(_connection_libnet_check_profile_validity(profile)) ||
2005 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2006 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
2007 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2008 return CONNECTION_ERROR_INVALID_PARAMETER;
2011 net_profile_info_t *profile_info = profile;
2012 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2013 if (net_info == NULL)
2014 return CONNECTION_ERROR_OPERATION_FAILED;
2016 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
2017 net_info->PrefixLen = prefix_len;
2018 net_info->SubnetMask.Data.Ipv4.s_addr = __profile_convert_prefix_len_to_netmask(prefix_len);
2020 net_info->PrefixLen6 = prefix_len;
2022 return CONNECTION_ERROR_NONE;
2025 EXPORT_API int connection_profile_get_prefix_length(connection_profile_h profile,
2026 connection_address_family_e address_family, int *prefix_len)
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) ||
2034 prefix_len == NULL) {
2035 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2036 return CONNECTION_ERROR_INVALID_PARAMETER;
2039 net_profile_info_t *profile_info = profile;
2040 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2041 if (net_info == NULL)
2042 return CONNECTION_ERROR_OPERATION_FAILED;
2044 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
2045 *prefix_len = net_info->PrefixLen;
2046 else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
2047 *prefix_len = net_info->PrefixLen6;
2049 return CONNECTION_ERROR_NONE;