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;
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);
62 ipaddr = (unsigned char *)&ip_addr->Data.Ipv6.s6_addr;
63 ipstr = g_try_malloc0(INET6_ADDRSTRLEN);
67 inet_ntop(AF_INET6, ipaddr, ipstr, INET6_ADDRSTRLEN);
73 static void __profile_init_cellular_profile(net_profile_info_t *profile_info, const char *keyword)
75 int default_subscriber_id = 0;
76 connection_profile_h profile = NULL;
78 profile_info->profile_type = NET_DEVICE_CELLULAR;
79 profile_info->ProfileState = NET_STATE_TYPE_IDLE;
80 profile_info->ProfileInfo.Pdp.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
81 profile_info->ProfileInfo.Pdp.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
82 g_strlcpy(profile_info->ProfileInfo.Pdp.Keyword, keyword, NET_PDP_APN_LEN_MAX);
84 if (vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE,
85 &default_subscriber_id) != 0)
86 CONNECTION_LOG(CONNECTION_ERROR,
87 "Failed to get VCONF_TELEPHONY_DEFAULT_DATA_SERVICE");
89 profile = (connection_profile_h)profile_info;
90 _connection_libnet_set_cellular_subscriber_id(profile, default_subscriber_id);
93 static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
95 profile_info->profile_type = NET_DEVICE_WIFI;
96 profile_info->ProfileState = NET_STATE_TYPE_IDLE;
97 profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
98 profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
99 profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
100 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
101 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
104 static const char* __profile_get_ethernet_proxy(void)
108 proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
111 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
118 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
121 case NET_SERVICE_INTERNET:
122 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
123 case NET_SERVICE_MMS:
124 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
125 case NET_SERVICE_PREPAID_INTERNET:
126 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
127 case NET_SERVICE_PREPAID_MMS:
128 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
129 case NET_SERVICE_TETHERING:
130 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
131 case NET_SERVICE_APPLICATION:
132 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
134 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
138 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
140 connection_profile_state_e cp_state;
143 case NET_STATE_TYPE_ONLINE:
144 case NET_STATE_TYPE_READY:
145 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
147 case NET_STATE_TYPE_IDLE:
148 case NET_STATE_TYPE_FAILURE:
149 case NET_STATE_TYPE_DISCONNECT:
150 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
152 case NET_STATE_TYPE_ASSOCIATION:
153 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
155 case NET_STATE_TYPE_CONFIGURATION:
156 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
165 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
168 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
169 return NET_SERVICE_INTERNET;
170 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
171 return NET_SERVICE_MMS;
172 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
173 return NET_SERVICE_PREPAID_INTERNET;
174 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
175 return NET_SERVICE_PREPAID_MMS;
176 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
177 return NET_SERVICE_TETHERING;
178 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
179 return NET_SERVICE_APPLICATION;
181 return NET_SERVICE_UNKNOWN;
185 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
187 net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
190 case CONNECTION_PROFILE_STATE_CONNECTED:
191 libnet_state = NET_STATE_TYPE_ONLINE;
193 case CONNECTION_PROFILE_STATE_DISCONNECTED:
194 libnet_state = NET_STATE_TYPE_IDLE;
196 case CONNECTION_PROFILE_STATE_ASSOCIATION:
197 libnet_state = NET_STATE_TYPE_ASSOCIATION;
199 case CONNECTION_PROFILE_STATE_CONFIGURATION:
200 libnet_state = NET_STATE_TYPE_CONFIGURATION;
208 /* Connection profile ********************************************************/
209 EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
211 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
213 if (type == CONNECTION_PROFILE_TYPE_CELLULAR)
214 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
215 else if (type == CONNECTION_PROFILE_TYPE_WIFI)
216 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
218 if (type != CONNECTION_PROFILE_TYPE_CELLULAR &&
219 type != CONNECTION_PROFILE_TYPE_WIFI) {
220 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
221 return CONNECTION_ERROR_INVALID_PARAMETER;
224 if (profile == NULL) {
225 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
226 return CONNECTION_ERROR_INVALID_PARAMETER;
229 int rv = _connection_libnet_check_profile_privilege();
230 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
232 else if (rv != CONNECTION_ERROR_NONE) {
233 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create profile");
234 return CONNECTION_ERROR_OPERATION_FAILED;
237 net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
238 if (profile_info == NULL)
239 return CONNECTION_ERROR_OUT_OF_MEMORY;
242 case CONNECTION_PROFILE_TYPE_CELLULAR:
243 if (keyword == NULL) {
244 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
245 g_free(profile_info);
246 return CONNECTION_ERROR_INVALID_PARAMETER;
248 __profile_init_cellular_profile(profile_info, keyword);
250 case CONNECTION_PROFILE_TYPE_WIFI:
251 __profile_init_wifi_profile(profile_info);
257 *profile = (connection_profile_h)profile_info;
258 _connection_libnet_add_to_profile_list(*profile);
260 return CONNECTION_ERROR_NONE;
263 EXPORT_API int connection_profile_destroy(connection_profile_h profile)
265 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
267 if (!(_connection_libnet_check_profile_validity(profile))) {
268 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
269 return CONNECTION_ERROR_INVALID_PARAMETER;
272 _connection_libnet_remove_from_profile_list(profile);
274 return CONNECTION_ERROR_NONE;
277 EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
279 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
281 if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
282 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
283 return CONNECTION_ERROR_INVALID_PARAMETER;
286 *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
287 if (*cloned_profile == NULL)
288 return CONNECTION_ERROR_OUT_OF_MEMORY;
290 memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
291 _connection_libnet_add_to_profile_list(*cloned_profile);
293 return CONNECTION_ERROR_NONE;
296 EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
298 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
300 if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
301 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
302 return CONNECTION_ERROR_INVALID_PARAMETER;
305 net_profile_info_t *profile_info = profile;
307 char *prof_id = strrchr(profile_info->ProfileName, '/');
309 return CONNECTION_ERROR_INVALID_PARAMETER;
312 *profile_id = g_strdup(prof_id);
314 if (*profile_id == NULL)
315 return CONNECTION_ERROR_OUT_OF_MEMORY;
317 return CONNECTION_ERROR_NONE;
320 EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
322 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
324 if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
325 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
326 return CONNECTION_ERROR_INVALID_PARAMETER;
329 net_profile_info_t *profile_info = profile;
331 switch (profile_info->profile_type) {
332 case NET_DEVICE_CELLULAR:
333 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
335 case NET_DEVICE_WIFI:
336 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
338 case NET_DEVICE_ETHERNET:
339 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName);
341 case NET_DEVICE_BLUETOOTH: {
342 char *bt_name = strrchr(profile_info->ProfileName, '/');
344 return CONNECTION_ERROR_INVALID_PARAMETER;
347 *profile_name = g_strdup(bt_name);
350 return CONNECTION_ERROR_INVALID_PARAMETER;
353 if (*profile_name == NULL)
354 return CONNECTION_ERROR_OUT_OF_MEMORY;
356 return CONNECTION_ERROR_NONE;
359 EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e* type)
361 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
363 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
364 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
365 return CONNECTION_ERROR_INVALID_PARAMETER;
368 net_profile_info_t *profile_info = profile;
370 switch (profile_info->profile_type) {
371 case NET_DEVICE_CELLULAR:
372 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
374 case NET_DEVICE_WIFI:
375 *type = CONNECTION_PROFILE_TYPE_WIFI;
377 case NET_DEVICE_ETHERNET:
378 *type = CONNECTION_PROFILE_TYPE_ETHERNET;
380 case NET_DEVICE_BLUETOOTH:
381 *type = CONNECTION_PROFILE_TYPE_BT;
384 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type");
385 return CONNECTION_ERROR_OPERATION_FAILED;
388 return CONNECTION_ERROR_NONE;
391 EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
393 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
395 if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
396 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
397 return CONNECTION_ERROR_INVALID_PARAMETER;
400 net_profile_info_t *profile_info = profile;
401 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
402 if (net_info == NULL)
403 return CONNECTION_ERROR_INVALID_PARAMETER;
405 *interface_name = g_strdup(net_info->DevName);
406 if (*interface_name == NULL)
407 return CONNECTION_ERROR_OUT_OF_MEMORY;
409 return CONNECTION_ERROR_NONE;
412 EXPORT_API int connection_profile_refresh(connection_profile_h profile)
416 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
418 if (!(_connection_libnet_check_profile_validity(profile))) {
419 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
420 return CONNECTION_ERROR_INVALID_PARAMETER;
423 net_profile_info_t profile_info_local;
424 net_profile_info_t *profile_info = profile;
426 rv = net_get_profile_info(profile_info->ProfileName, &profile_info_local);
427 if (rv == NET_ERR_ACCESS_DENIED) {
428 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
429 return CONNECTION_ERROR_PERMISSION_DENIED;
430 } else if (rv != NET_ERR_NONE) {
431 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile information");
432 return CONNECTION_ERROR_OPERATION_FAILED;
435 memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
437 return CONNECTION_ERROR_NONE;
440 EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
442 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
444 if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
445 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
446 return CONNECTION_ERROR_INVALID_PARAMETER;
449 net_profile_info_t *profile_info = profile;
450 *state = _profile_convert_to_cp_state(profile_info->ProfileState);
452 return CONNECTION_ERROR_NONE;
455 EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
456 connection_address_family_e address_family, connection_ip_config_type_e* type)
458 net_ip_config_type_t profile_type;
460 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
462 if (!(_connection_libnet_check_profile_validity(profile)) ||
463 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
464 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
466 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
467 return CONNECTION_ERROR_INVALID_PARAMETER;
470 net_profile_info_t *profile_info = profile;
471 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
472 if (net_info == NULL)
473 return CONNECTION_ERROR_OPERATION_FAILED;
475 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
476 profile_type = net_info->IpConfigType;
478 profile_type = net_info->IpConfigType6;
480 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
481 switch (profile_type) {
482 case NET_IP_CONFIG_TYPE_STATIC:
483 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
486 case NET_IP_CONFIG_TYPE_DYNAMIC:
487 *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
490 case NET_IP_CONFIG_TYPE_AUTO_IP:
491 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
494 case NET_IP_CONFIG_TYPE_FIXED:
495 *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
498 case NET_IP_CONFIG_TYPE_OFF:
499 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
502 return CONNECTION_ERROR_OPERATION_FAILED;
505 switch (profile_type) {
506 case NET_IP_CONFIG_TYPE_STATIC:
507 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
510 case NET_IP_CONFIG_TYPE_AUTO_IP:
511 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
514 case NET_IP_CONFIG_TYPE_OFF:
515 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
519 return CONNECTION_ERROR_OPERATION_FAILED;
524 return CONNECTION_ERROR_NONE;
527 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
528 connection_address_family_e address_family, char** ip_address)
530 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
532 if (!(_connection_libnet_check_profile_validity(profile)) ||
533 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
534 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
535 ip_address == NULL) {
536 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
537 return CONNECTION_ERROR_INVALID_PARAMETER;
540 net_profile_info_t *profile_info = profile;
541 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
542 if (net_info == NULL)
543 return CONNECTION_ERROR_OPERATION_FAILED;
545 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
546 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr6,
549 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
552 if (*ip_address == NULL)
553 return CONNECTION_ERROR_OUT_OF_MEMORY;
555 return CONNECTION_ERROR_NONE;
558 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
559 connection_address_family_e address_family, char** subnet_mask)
563 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
565 if (!(_connection_libnet_check_profile_validity(profile)) ||
566 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
567 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
568 subnet_mask == NULL) {
569 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
570 return CONNECTION_ERROR_INVALID_PARAMETER;
573 net_profile_info_t *profile_info = profile;
574 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
575 if (net_info == NULL)
576 return CONNECTION_ERROR_OPERATION_FAILED;
578 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
579 prefixlen = g_try_malloc0(MAX_PREFIX_LENGTH);
580 if (prefixlen != NULL) {
581 snprintf(prefixlen, MAX_PREFIX_LENGTH, "%d", net_info->PrefixLen6);
582 *subnet_mask = prefixlen;
586 *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask,
589 if (*subnet_mask == NULL)
590 return CONNECTION_ERROR_OUT_OF_MEMORY;
592 return CONNECTION_ERROR_NONE;
595 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
596 connection_address_family_e address_family, char** gateway_address)
598 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
600 if (!(_connection_libnet_check_profile_validity(profile)) ||
601 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
602 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
603 gateway_address == NULL) {
604 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
605 return CONNECTION_ERROR_INVALID_PARAMETER;
608 net_profile_info_t *profile_info = profile;
609 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
610 if (net_info == NULL)
611 return CONNECTION_ERROR_OPERATION_FAILED;
613 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
614 *gateway_address = __profile_convert_ip_to_string(
615 &net_info->GatewayAddr6, address_family);
617 *gateway_address = __profile_convert_ip_to_string(
618 &net_info->GatewayAddr, address_family);
620 if (*gateway_address == NULL)
621 return CONNECTION_ERROR_OUT_OF_MEMORY;
623 return CONNECTION_ERROR_NONE;
626 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
627 connection_address_family_e address_family, char** dns_address)
629 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
631 if (!(_connection_libnet_check_profile_validity(profile)) ||
632 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
633 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
634 dns_address == NULL ||
636 order > NET_DNS_ADDR_MAX) {
637 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
638 return CONNECTION_ERROR_INVALID_PARAMETER;
641 net_profile_info_t *profile_info = profile;
642 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
643 if (net_info == NULL)
644 return CONNECTION_ERROR_OPERATION_FAILED;
646 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
647 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
649 else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
650 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1],
653 CONNECTION_LOG(CONNECTION_ERROR, "Invalid address family\n");
655 if (*dns_address == NULL)
656 return CONNECTION_ERROR_OUT_OF_MEMORY;
658 return CONNECTION_ERROR_NONE;
661 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e* type)
663 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
665 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
666 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
667 return CONNECTION_ERROR_INVALID_PARAMETER;
671 net_profile_info_t *profile_info = profile;
672 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
673 if (net_info == NULL)
674 return CONNECTION_ERROR_OPERATION_FAILED;
676 if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
677 proxy = __profile_get_ethernet_proxy();
679 *type = CONNECTION_PROXY_TYPE_DIRECT;
681 *type = CONNECTION_PROXY_TYPE_MANUAL;
683 return CONNECTION_ERROR_NONE;
686 switch (net_info->ProxyMethod) {
687 case NET_PROXY_TYPE_DIRECT:
688 *type = CONNECTION_PROXY_TYPE_DIRECT;
690 case NET_PROXY_TYPE_AUTO:
691 *type = CONNECTION_PROXY_TYPE_AUTO;
693 case NET_PROXY_TYPE_MANUAL:
694 *type = CONNECTION_PROXY_TYPE_MANUAL;
696 case NET_PROXY_TYPE_UNKNOWN:
698 return CONNECTION_ERROR_OPERATION_FAILED;
701 return CONNECTION_ERROR_NONE;
704 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
705 connection_address_family_e address_family, char** proxy_address)
707 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
709 if (!(_connection_libnet_check_profile_validity(profile)) ||
710 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
711 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
712 proxy_address == NULL) {
713 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
714 return CONNECTION_ERROR_INVALID_PARAMETER;
717 net_profile_info_t *profile_info = profile;
718 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
719 if (net_info == NULL)
720 return CONNECTION_ERROR_OPERATION_FAILED;
722 *proxy_address = g_strdup(net_info->ProxyAddr);
724 if (*proxy_address == NULL)
725 return CONNECTION_ERROR_OUT_OF_MEMORY;
727 return CONNECTION_ERROR_NONE;
730 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
731 connection_address_family_e address_family, connection_ip_config_type_e type)
733 net_ip_config_type_t *profile_type = NULL;
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 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
741 return CONNECTION_ERROR_INVALID_PARAMETER;
744 net_profile_info_t *profile_info = profile;
745 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
746 if (net_info == NULL)
747 return CONNECTION_ERROR_OPERATION_FAILED;
749 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
750 profile_type = &net_info->IpConfigType ;
752 profile_type = &net_info->IpConfigType6 ;
754 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
756 case CONNECTION_IP_CONFIG_TYPE_STATIC:
757 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
758 net_info->IpAddr.Data.Ipv4.s_addr = 0;
759 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
760 net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
763 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
764 *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
767 case CONNECTION_IP_CONFIG_TYPE_AUTO:
768 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
771 case CONNECTION_IP_CONFIG_TYPE_FIXED:
772 net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
775 case CONNECTION_IP_CONFIG_TYPE_NONE:
776 *profile_type = NET_IP_CONFIG_TYPE_OFF;
780 return CONNECTION_ERROR_INVALID_PARAMETER;
784 case CONNECTION_IP_CONFIG_TYPE_STATIC:
785 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
786 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
787 net_info->PrefixLen6 = 0 ;
788 inet_pton(AF_INET6, "::",
789 &net_info->GatewayAddr6.Data.Ipv6);
792 case CONNECTION_IP_CONFIG_TYPE_AUTO:
793 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
796 case CONNECTION_IP_CONFIG_TYPE_NONE:
797 *profile_type = NET_IP_CONFIG_TYPE_OFF;
801 return CONNECTION_ERROR_INVALID_PARAMETER;
805 return CONNECTION_ERROR_NONE;
808 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
809 connection_address_family_e address_family, const char* ip_address)
811 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
813 if (!(_connection_libnet_check_profile_validity(profile)) ||
814 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
815 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
816 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
817 return CONNECTION_ERROR_INVALID_PARAMETER;
820 net_profile_info_t *profile_info = profile;
821 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
822 if (net_info == NULL)
823 return CONNECTION_ERROR_OPERATION_FAILED;
825 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
826 if (ip_address == NULL)
827 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
828 else if (inet_pton(AF_INET6, ip_address,
829 &net_info->IpAddr6.Data.Ipv6) < 1)
830 return CONNECTION_ERROR_INVALID_PARAMETER;
832 if (ip_address == NULL)
833 net_info->IpAddr.Data.Ipv4.s_addr = 0;
834 else if (inet_pton(AF_INET, ip_address,
835 &net_info->IpAddr.Data.Ipv4) < 1)
836 return CONNECTION_ERROR_INVALID_PARAMETER;
839 return CONNECTION_ERROR_NONE;
842 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
843 connection_address_family_e address_family, const char* subnet_mask)
845 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
847 if (!(_connection_libnet_check_profile_validity(profile)) ||
848 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
849 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
850 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
851 return CONNECTION_ERROR_INVALID_PARAMETER;
854 net_profile_info_t *profile_info = profile;
855 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
856 if (net_info == NULL)
857 return CONNECTION_ERROR_OPERATION_FAILED;
859 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
860 if (subnet_mask == NULL)
861 net_info->PrefixLen6 = 0 ;
863 net_info->PrefixLen6 = atoi(subnet_mask) ;
865 if (subnet_mask == NULL)
866 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
867 else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4) < 1)
868 return CONNECTION_ERROR_INVALID_PARAMETER;
871 return CONNECTION_ERROR_NONE;
874 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
875 connection_address_family_e address_family, const char* gateway_address)
877 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
879 if (!(_connection_libnet_check_profile_validity(profile)) ||
880 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
881 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
882 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
883 return CONNECTION_ERROR_INVALID_PARAMETER;
886 net_profile_info_t *profile_info = profile;
887 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
888 if (net_info == NULL)
889 return CONNECTION_ERROR_OPERATION_FAILED;
891 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
892 if (gateway_address == NULL)
893 inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
894 else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1)
895 return CONNECTION_ERROR_INVALID_PARAMETER;
897 if (gateway_address == NULL)
898 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
899 else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1)
900 return CONNECTION_ERROR_INVALID_PARAMETER;
903 return CONNECTION_ERROR_NONE;
906 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
907 connection_address_family_e address_family, const char* dns_address)
909 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
911 if (!(_connection_libnet_check_profile_validity(profile)) ||
912 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
913 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
915 order > NET_DNS_ADDR_MAX) {
916 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
917 return CONNECTION_ERROR_INVALID_PARAMETER;
920 net_profile_info_t *profile_info = profile;
921 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
922 if (net_info == NULL)
923 return CONNECTION_ERROR_OPERATION_FAILED;
925 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
926 net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
927 if (dns_address == NULL)
928 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
929 else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1)
930 return CONNECTION_ERROR_INVALID_PARAMETER;
931 if (net_info->DnsCount6 < order)
932 net_info->DnsCount6 = order;
934 net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
935 if (dns_address == NULL)
936 net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
937 else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1)
938 return CONNECTION_ERROR_INVALID_PARAMETER;
939 if (net_info->DnsCount < order)
940 net_info->DnsCount = order;
943 return CONNECTION_ERROR_NONE;
946 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
948 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
950 if (!(_connection_libnet_check_profile_validity(profile))) {
951 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
952 return CONNECTION_ERROR_INVALID_PARAMETER;
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;
961 case CONNECTION_PROXY_TYPE_DIRECT:
962 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
964 case CONNECTION_PROXY_TYPE_AUTO:
965 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
967 case CONNECTION_PROXY_TYPE_MANUAL:
968 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
971 return CONNECTION_ERROR_INVALID_PARAMETER;
974 return CONNECTION_ERROR_NONE;
977 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
978 connection_address_family_e address_family, const char* proxy_address)
980 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
982 if (!(_connection_libnet_check_profile_validity(profile)) ||
983 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
984 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
985 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
986 return CONNECTION_ERROR_INVALID_PARAMETER;
989 net_profile_info_t *profile_info = profile;
990 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
991 if (net_info == NULL)
992 return CONNECTION_ERROR_OPERATION_FAILED;
994 if (proxy_address == NULL)
995 net_info->ProxyAddr[0] = '\0';
997 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
999 return CONNECTION_ERROR_NONE;
1002 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
1003 connection_profile_state_changed_cb callback, void* user_data)
1005 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1007 if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
1008 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1009 return CONNECTION_ERROR_INVALID_PARAMETER;
1012 if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
1013 return CONNECTION_ERROR_NONE;
1015 return CONNECTION_ERROR_OPERATION_FAILED;
1018 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
1020 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1022 if (!(_connection_libnet_check_profile_validity(profile))) {
1023 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1024 return CONNECTION_ERROR_INVALID_PARAMETER;
1027 if (_connection_libnet_remove_from_profile_cb_list(profile) != true)
1028 return CONNECTION_ERROR_INVALID_PARAMETER;
1030 return CONNECTION_ERROR_NONE;
1034 /* Wi-Fi profile *************************************************************/
1035 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
1037 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1039 if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
1040 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1041 return CONNECTION_ERROR_INVALID_PARAMETER;
1044 net_profile_info_t *profile_info = profile;
1046 if (profile_info->profile_type != NET_DEVICE_WIFI)
1047 return CONNECTION_ERROR_INVALID_PARAMETER;
1049 *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
1051 return CONNECTION_ERROR_OUT_OF_MEMORY;
1053 return CONNECTION_ERROR_NONE;
1056 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
1058 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1060 if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
1061 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1062 return CONNECTION_ERROR_INVALID_PARAMETER;
1065 net_profile_info_t *profile_info = profile;
1067 if (profile_info->profile_type != NET_DEVICE_WIFI)
1068 return CONNECTION_ERROR_INVALID_PARAMETER;
1070 *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
1072 return CONNECTION_ERROR_OUT_OF_MEMORY;
1074 return CONNECTION_ERROR_NONE;
1077 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1079 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1081 if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
1082 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1083 return CONNECTION_ERROR_INVALID_PARAMETER;
1086 net_profile_info_t *profile_info = profile;
1088 if (profile_info->profile_type != NET_DEVICE_WIFI)
1089 return CONNECTION_ERROR_INVALID_PARAMETER;
1091 *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1093 return CONNECTION_ERROR_NONE;
1096 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1098 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1100 if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
1101 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1102 return CONNECTION_ERROR_INVALID_PARAMETER;
1105 net_profile_info_t *profile_info = profile;
1107 if (profile_info->profile_type != NET_DEVICE_WIFI)
1108 return CONNECTION_ERROR_INVALID_PARAMETER;
1110 *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1112 return CONNECTION_ERROR_NONE;
1115 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1117 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1119 if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
1120 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1121 return CONNECTION_ERROR_INVALID_PARAMETER;
1124 net_profile_info_t *profile_info = profile;
1126 if (profile_info->profile_type != NET_DEVICE_WIFI)
1127 return CONNECTION_ERROR_INVALID_PARAMETER;
1129 *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate;
1131 return CONNECTION_ERROR_NONE;
1134 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e* type)
1136 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1138 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1139 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1140 return CONNECTION_ERROR_INVALID_PARAMETER;
1143 net_profile_info_t *profile_info = profile;
1145 if (profile_info->profile_type != NET_DEVICE_WIFI)
1146 return CONNECTION_ERROR_INVALID_PARAMETER;
1148 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1149 case WLAN_SEC_MODE_NONE:
1150 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1152 case WLAN_SEC_MODE_WEP:
1153 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1155 case WLAN_SEC_MODE_IEEE8021X:
1156 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1158 case WLAN_SEC_MODE_WPA_PSK:
1159 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1161 case WLAN_SEC_MODE_WPA2_PSK:
1162 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1165 return CONNECTION_ERROR_OPERATION_FAILED;
1168 return CONNECTION_ERROR_NONE;
1171 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e* type)
1173 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1175 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1176 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1177 return CONNECTION_ERROR_INVALID_PARAMETER;
1180 net_profile_info_t *profile_info = profile;
1182 if (profile_info->profile_type != NET_DEVICE_WIFI)
1183 return CONNECTION_ERROR_INVALID_PARAMETER;
1185 switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1186 case WLAN_ENC_MODE_NONE:
1187 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1189 case WLAN_ENC_MODE_WEP:
1190 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1192 case WLAN_ENC_MODE_TKIP:
1193 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1195 case WLAN_ENC_MODE_AES:
1196 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1198 case WLAN_ENC_MODE_TKIP_AES_MIXED:
1199 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1202 return CONNECTION_ERROR_OPERATION_FAILED;
1205 return CONNECTION_ERROR_NONE;
1208 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1210 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1212 if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1213 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1214 return CONNECTION_ERROR_INVALID_PARAMETER;
1217 net_profile_info_t *profile_info = profile;
1219 if (profile_info->profile_type != NET_DEVICE_WIFI)
1220 return CONNECTION_ERROR_INVALID_PARAMETER;
1222 if (profile_info->Favourite) {
1224 return CONNECTION_ERROR_NONE;
1227 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1228 case WLAN_SEC_MODE_NONE:
1231 case WLAN_SEC_MODE_WEP:
1232 case WLAN_SEC_MODE_IEEE8021X:
1233 case WLAN_SEC_MODE_WPA_PSK:
1234 case WLAN_SEC_MODE_WPA2_PSK:
1238 return CONNECTION_ERROR_OPERATION_FAILED;
1241 return CONNECTION_ERROR_NONE;
1244 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1246 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1248 if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1249 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1250 return CONNECTION_ERROR_INVALID_PARAMETER;
1253 net_profile_info_t *profile_info = profile;
1255 if (profile_info->profile_type != NET_DEVICE_WIFI)
1256 return CONNECTION_ERROR_INVALID_PARAMETER;
1258 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1259 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1261 return CONNECTION_ERROR_NONE;
1264 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1266 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1268 if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1269 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1270 return CONNECTION_ERROR_INVALID_PARAMETER;
1273 net_profile_info_t *profile_info = profile;
1275 if (profile_info->profile_type != NET_DEVICE_WIFI)
1276 return CONNECTION_ERROR_INVALID_PARAMETER;
1278 if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1283 return CONNECTION_ERROR_NONE;
1287 /* Cellular profile **********************************************************/
1288 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1289 connection_cellular_service_type_e* type)
1291 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1293 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1294 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1295 return CONNECTION_ERROR_INVALID_PARAMETER;
1298 net_profile_info_t *profile_info = profile;
1300 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1301 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1302 return CONNECTION_ERROR_INVALID_PARAMETER;
1305 *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1307 if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1308 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed");
1309 return CONNECTION_ERROR_OPERATION_FAILED;
1312 return CONNECTION_ERROR_NONE;
1315 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1317 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1319 if (!(_connection_libnet_check_profile_validity(profile)) || apn == 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_CELLULAR) {
1327 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1328 return CONNECTION_ERROR_INVALID_PARAMETER;
1331 *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1333 return CONNECTION_ERROR_OUT_OF_MEMORY;
1335 return CONNECTION_ERROR_NONE;
1338 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1339 connection_cellular_auth_type_e* type, char** user_name, char** password)
1341 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1343 if (!(_connection_libnet_check_profile_validity(profile)) ||
1344 type == NULL || user_name == NULL || password == NULL) {
1345 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1346 return CONNECTION_ERROR_INVALID_PARAMETER;
1349 net_profile_info_t *profile_info = profile;
1351 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1352 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1353 return CONNECTION_ERROR_INVALID_PARAMETER;
1356 switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1357 case NET_PDP_AUTH_NONE:
1358 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1360 case NET_PDP_AUTH_PAP:
1361 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1363 case NET_PDP_AUTH_CHAP:
1364 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1367 return CONNECTION_ERROR_OPERATION_FAILED;
1370 *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1371 if (*user_name == NULL)
1372 return CONNECTION_ERROR_OUT_OF_MEMORY;
1374 *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1375 if (*password == NULL) {
1377 return CONNECTION_ERROR_OUT_OF_MEMORY;
1380 return CONNECTION_ERROR_NONE;
1383 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1385 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1387 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1388 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1389 return CONNECTION_ERROR_INVALID_PARAMETER;
1392 net_profile_info_t *profile_info = profile;
1394 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1395 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1396 return CONNECTION_ERROR_INVALID_PARAMETER;
1399 *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1400 if (*home_url == NULL)
1401 return CONNECTION_ERROR_OUT_OF_MEMORY;
1403 return CONNECTION_ERROR_NONE;
1406 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1408 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1410 if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1411 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1412 return CONNECTION_ERROR_INVALID_PARAMETER;
1415 net_profile_info_t *profile_info = profile;
1417 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1418 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1419 return CONNECTION_ERROR_INVALID_PARAMETER;
1422 if (profile_info->ProfileInfo.Pdp.Roaming)
1425 *is_roaming = false;
1427 return CONNECTION_ERROR_NONE;
1430 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
1432 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1434 if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
1435 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1436 return CONNECTION_ERROR_INVALID_PARAMETER;
1439 net_profile_info_t *profile_info = profile;
1441 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1442 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1443 return CONNECTION_ERROR_INVALID_PARAMETER;
1446 if (profile_info->ProfileInfo.Pdp.Hidden)
1451 return CONNECTION_ERROR_NONE;
1454 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
1456 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1458 if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
1459 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1460 return CONNECTION_ERROR_INVALID_PARAMETER;
1463 net_profile_info_t *profile_info = profile;
1465 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1466 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1467 return CONNECTION_ERROR_INVALID_PARAMETER;
1470 if (profile_info->ProfileInfo.Pdp.Editable)
1471 *is_editable = true;
1473 *is_editable = false;
1475 return CONNECTION_ERROR_NONE;
1478 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
1480 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1482 if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
1483 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1484 return CONNECTION_ERROR_INVALID_PARAMETER;
1487 net_profile_info_t *profile_info = profile;
1489 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1490 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1491 return CONNECTION_ERROR_INVALID_PARAMETER;
1494 if (profile_info->ProfileInfo.Pdp.DefaultConn)
1497 *is_default = false;
1499 return CONNECTION_ERROR_NONE;
1502 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
1503 connection_cellular_service_type_e service_type)
1505 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1507 if (!(_connection_libnet_check_profile_validity(profile))) {
1508 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1509 return CONNECTION_ERROR_INVALID_PARAMETER;
1512 net_profile_info_t *profile_info = profile;
1514 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1515 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1516 return CONNECTION_ERROR_INVALID_PARAMETER;
1519 switch (service_type) {
1520 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1521 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1523 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1524 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1526 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1527 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1529 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1530 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1532 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1533 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1535 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1536 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1538 case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1540 return CONNECTION_ERROR_INVALID_PARAMETER;
1543 return CONNECTION_ERROR_NONE;
1546 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1548 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1550 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1551 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1552 return CONNECTION_ERROR_INVALID_PARAMETER;
1555 net_profile_info_t *profile_info = profile;
1557 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1558 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1559 return CONNECTION_ERROR_INVALID_PARAMETER;
1562 g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1564 return CONNECTION_ERROR_NONE;
1567 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1568 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1570 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1572 if (!(_connection_libnet_check_profile_validity(profile)) ||
1573 user_name == NULL || password == NULL) {
1574 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1575 return CONNECTION_ERROR_INVALID_PARAMETER;
1578 net_profile_info_t *profile_info = profile;
1580 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1581 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1582 return CONNECTION_ERROR_INVALID_PARAMETER;
1586 case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1587 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1589 case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1590 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1592 case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1593 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1596 return CONNECTION_ERROR_INVALID_PARAMETER;
1599 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1600 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1602 return CONNECTION_ERROR_NONE;
1605 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1607 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1609 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1610 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1611 return CONNECTION_ERROR_INVALID_PARAMETER;
1614 net_profile_info_t *profile_info = profile;
1616 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1617 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1618 return CONNECTION_ERROR_INVALID_PARAMETER;
1621 g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1623 return CONNECTION_ERROR_NONE;