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.
20 #include <arpa/inet.h>
22 #include <vconf/vconf.h>
23 #include "net_connection_private.h"
25 #define HTTP_PROXY "http_proxy"
26 #define MAX_PREFIX_LENGTH 6
28 static net_dev_info_t* __profile_get_net_info(net_profile_info_t *profile_info)
30 switch (profile_info->profile_type) {
31 case NET_DEVICE_CELLULAR:
32 return &profile_info->ProfileInfo.Pdp.net_info;
34 return &profile_info->ProfileInfo.Wlan.net_info;
35 case NET_DEVICE_ETHERNET:
36 return &profile_info->ProfileInfo.Ethernet.net_info;
37 case NET_DEVICE_BLUETOOTH:
38 return &profile_info->ProfileInfo.Bluetooth.net_info;
39 case NET_DEVICE_DEFAULT:
41 case NET_DEVICE_UNKNOWN:
48 static char *__profile_convert_ip_to_string(net_addr_t *ip_addr, connection_address_family_e address_family)
50 unsigned char *ipaddr = NULL;
53 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
54 ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
55 ipstr = g_try_malloc0(INET_ADDRSTRLEN);
59 inet_ntop(AF_INET, ipaddr, ipstr, INET_ADDRSTRLEN);
61 ipaddr = (unsigned char *)&ip_addr->Data.Ipv6.s6_addr;
62 ipstr = g_try_malloc0(INET6_ADDRSTRLEN);
66 inet_ntop(AF_INET6, ipaddr, ipstr, INET6_ADDRSTRLEN);
72 static void __profile_init_cellular_profile(net_profile_info_t *profile_info, const char *keyword)
74 int default_subscriber_id = 0;
75 connection_profile_h profile = NULL;
77 profile_info->profile_type = NET_DEVICE_CELLULAR;
78 profile_info->ProfileState = NET_STATE_TYPE_IDLE;
79 profile_info->ProfileInfo.Pdp.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
80 profile_info->ProfileInfo.Pdp.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
81 g_strlcpy(profile_info->ProfileInfo.Pdp.Keyword, keyword, NET_PDP_APN_LEN_MAX);
83 if (vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE,
84 &default_subscriber_id) != 0)
85 CONNECTION_LOG(CONNECTION_ERROR,
86 "Failed to get VCONF_TELEPHONY_DEFAULT_DATA_SERVICE");
88 profile = (connection_profile_h)profile_info;
89 _connection_libnet_set_cellular_subscriber_id(profile, default_subscriber_id);
92 static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
94 profile_info->profile_type = NET_DEVICE_WIFI;
95 profile_info->ProfileState = NET_STATE_TYPE_IDLE;
96 profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
97 profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
98 profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
99 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
100 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
103 static const char* __profile_get_ethernet_proxy(void)
107 proxy = getenv(HTTP_PROXY);
110 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
117 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
120 case NET_SERVICE_INTERNET:
121 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
122 case NET_SERVICE_MMS:
123 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
124 case NET_SERVICE_PREPAID_INTERNET:
125 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
126 case NET_SERVICE_PREPAID_MMS:
127 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
128 case NET_SERVICE_TETHERING:
129 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
130 case NET_SERVICE_APPLICATION:
131 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
133 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
137 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
139 connection_profile_state_e cp_state;
142 case NET_STATE_TYPE_ONLINE:
143 case NET_STATE_TYPE_READY:
144 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
146 case NET_STATE_TYPE_IDLE:
147 case NET_STATE_TYPE_FAILURE:
148 case NET_STATE_TYPE_DISCONNECT:
149 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
151 case NET_STATE_TYPE_ASSOCIATION:
152 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
154 case NET_STATE_TYPE_CONFIGURATION:
155 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
164 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
167 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
168 return NET_SERVICE_INTERNET;
169 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
170 return NET_SERVICE_MMS;
171 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
172 return NET_SERVICE_PREPAID_INTERNET;
173 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
174 return NET_SERVICE_PREPAID_MMS;
175 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
176 return NET_SERVICE_TETHERING;
177 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
178 return NET_SERVICE_APPLICATION;
180 return NET_SERVICE_UNKNOWN;
184 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
186 net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
189 case CONNECTION_PROFILE_STATE_CONNECTED:
190 libnet_state = NET_STATE_TYPE_ONLINE;
192 case CONNECTION_PROFILE_STATE_DISCONNECTED:
193 libnet_state = NET_STATE_TYPE_IDLE;
195 case CONNECTION_PROFILE_STATE_ASSOCIATION:
196 libnet_state = NET_STATE_TYPE_ASSOCIATION;
198 case CONNECTION_PROFILE_STATE_CONFIGURATION:
199 libnet_state = NET_STATE_TYPE_CONFIGURATION;
207 /* Connection profile ********************************************************/
208 EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
210 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
212 if(type == CONNECTION_PROFILE_TYPE_CELLULAR)
213 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
214 else if(type == CONNECTION_PROFILE_TYPE_WIFI)
215 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
217 if ((type != CONNECTION_PROFILE_TYPE_CELLULAR &&
218 type != CONNECTION_PROFILE_TYPE_WIFI) || profile == NULL) {
219 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
220 return CONNECTION_ERROR_INVALID_PARAMETER;
223 net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
224 if (profile_info == NULL)
225 return CONNECTION_ERROR_OUT_OF_MEMORY;
228 case CONNECTION_PROFILE_TYPE_CELLULAR:
229 if (keyword == NULL) {
230 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
231 g_free(profile_info);
232 return CONNECTION_ERROR_INVALID_PARAMETER;
234 __profile_init_cellular_profile(profile_info, keyword);
236 case CONNECTION_PROFILE_TYPE_WIFI:
237 __profile_init_wifi_profile(profile_info);
243 *profile = (connection_profile_h)profile_info;
244 _connection_libnet_add_to_profile_list(*profile);
246 return CONNECTION_ERROR_NONE;
249 EXPORT_API int connection_profile_destroy(connection_profile_h profile)
251 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
253 if (!(_connection_libnet_check_profile_validity(profile))) {
254 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
255 return CONNECTION_ERROR_INVALID_PARAMETER;
258 _connection_libnet_remove_from_profile_list(profile);
260 return CONNECTION_ERROR_NONE;
263 EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
265 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
267 if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
268 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
269 return CONNECTION_ERROR_INVALID_PARAMETER;
272 *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
273 if (*cloned_profile == NULL)
274 return CONNECTION_ERROR_OUT_OF_MEMORY;
276 memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
277 _connection_libnet_add_to_profile_list(*cloned_profile);
279 return CONNECTION_ERROR_NONE;
282 EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
284 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
286 if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
287 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
288 return CONNECTION_ERROR_INVALID_PARAMETER;
291 net_profile_info_t *profile_info = profile;
293 char *prof_id = strrchr(profile_info->ProfileName, '/');
295 return CONNECTION_ERROR_INVALID_PARAMETER;
298 *profile_id = g_strdup(prof_id);
300 if (*profile_id == NULL)
301 return CONNECTION_ERROR_OUT_OF_MEMORY;
303 return CONNECTION_ERROR_NONE;
306 EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
308 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
310 if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
311 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
312 return CONNECTION_ERROR_INVALID_PARAMETER;
315 net_profile_info_t *profile_info = profile;
317 switch (profile_info->profile_type) {
318 case NET_DEVICE_CELLULAR:
319 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
321 case NET_DEVICE_WIFI:
322 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
324 case NET_DEVICE_ETHERNET:
325 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName);
327 case NET_DEVICE_BLUETOOTH: {
328 char *bt_name = strrchr(profile_info->ProfileName, '/');
330 return CONNECTION_ERROR_INVALID_PARAMETER;
333 *profile_name = g_strdup(bt_name);
336 return CONNECTION_ERROR_INVALID_PARAMETER;
339 if (*profile_name == NULL)
340 return CONNECTION_ERROR_OUT_OF_MEMORY;
342 return CONNECTION_ERROR_NONE;
345 EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e* type)
347 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
349 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
350 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
351 return CONNECTION_ERROR_INVALID_PARAMETER;
354 net_profile_info_t *profile_info = profile;
356 switch (profile_info->profile_type) {
357 case NET_DEVICE_CELLULAR:
358 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
360 case NET_DEVICE_WIFI:
361 *type = CONNECTION_PROFILE_TYPE_WIFI;
363 case NET_DEVICE_ETHERNET:
364 *type = CONNECTION_PROFILE_TYPE_ETHERNET;
366 case NET_DEVICE_BLUETOOTH:
367 *type = CONNECTION_PROFILE_TYPE_BT;
370 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type\n");
371 return CONNECTION_ERROR_OPERATION_FAILED;
374 return CONNECTION_ERROR_NONE;
377 EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
379 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
381 if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
382 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
383 return CONNECTION_ERROR_INVALID_PARAMETER;
386 net_profile_info_t *profile_info = profile;
387 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
388 if (net_info == NULL)
389 return CONNECTION_ERROR_INVALID_PARAMETER;
391 *interface_name = g_strdup(net_info->DevName);
392 if (*interface_name == NULL)
393 return CONNECTION_ERROR_OUT_OF_MEMORY;
395 return CONNECTION_ERROR_NONE;
398 EXPORT_API int connection_profile_refresh(connection_profile_h profile)
402 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
404 if (!(_connection_libnet_check_profile_validity(profile))) {
405 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
406 return CONNECTION_ERROR_INVALID_PARAMETER;
409 net_profile_info_t profile_info_local;
410 net_profile_info_t *profile_info = profile;
412 rv = net_get_profile_info(profile_info->ProfileName, &profile_info_local);
413 if (rv == NET_ERR_ACCESS_DENIED) {
414 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
415 return CONNECTION_ERROR_PERMISSION_DENIED;
416 } else if (rv != NET_ERR_NONE) {
417 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile information");
418 return CONNECTION_ERROR_OPERATION_FAILED;
421 memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
423 return CONNECTION_ERROR_NONE;
426 EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
428 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
430 if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
431 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
432 return CONNECTION_ERROR_INVALID_PARAMETER;
435 net_profile_info_t *profile_info = profile;
436 *state = _profile_convert_to_cp_state(profile_info->ProfileState);
438 return CONNECTION_ERROR_OPERATION_FAILED;
440 return CONNECTION_ERROR_NONE;
443 EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
444 connection_address_family_e address_family, connection_ip_config_type_e* type)
446 net_ip_config_type_t profile_type;
448 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
450 if (!(_connection_libnet_check_profile_validity(profile)) ||
451 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
452 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
454 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
455 return CONNECTION_ERROR_INVALID_PARAMETER;
458 net_profile_info_t *profile_info = profile;
459 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
460 if (net_info == NULL)
461 return CONNECTION_ERROR_OPERATION_FAILED;
463 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
464 profile_type = net_info->IpConfigType;
466 profile_type = net_info->IpConfigType6;
468 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
469 switch (profile_type) {
470 case NET_IP_CONFIG_TYPE_STATIC:
471 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
474 case NET_IP_CONFIG_TYPE_DYNAMIC:
475 *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
478 case NET_IP_CONFIG_TYPE_AUTO_IP:
479 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
482 case NET_IP_CONFIG_TYPE_FIXED:
483 *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
486 case NET_IP_CONFIG_TYPE_OFF:
487 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
490 return CONNECTION_ERROR_OPERATION_FAILED;
493 switch (profile_type) {
494 case NET_IP_CONFIG_TYPE_STATIC:
495 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
498 case NET_IP_CONFIG_TYPE_AUTO_IP:
499 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
502 case NET_IP_CONFIG_TYPE_OFF:
503 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
507 return CONNECTION_ERROR_OPERATION_FAILED;
512 return CONNECTION_ERROR_NONE;
515 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
516 connection_address_family_e address_family, char** ip_address)
518 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
520 if (!(_connection_libnet_check_profile_validity(profile)) ||
521 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
522 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
523 ip_address == NULL) {
524 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
525 return CONNECTION_ERROR_INVALID_PARAMETER;
528 net_profile_info_t *profile_info = profile;
529 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
530 if (net_info == NULL)
531 return CONNECTION_ERROR_OPERATION_FAILED;
533 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
534 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr6,
537 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
540 if (*ip_address == NULL)
541 return CONNECTION_ERROR_OUT_OF_MEMORY;
543 return CONNECTION_ERROR_NONE;
546 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
547 connection_address_family_e address_family, char** subnet_mask)
551 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
553 if (!(_connection_libnet_check_profile_validity(profile)) ||
554 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
555 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
556 subnet_mask == NULL) {
557 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
558 return CONNECTION_ERROR_INVALID_PARAMETER;
561 net_profile_info_t *profile_info = profile;
562 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
563 if (net_info == NULL)
564 return CONNECTION_ERROR_OPERATION_FAILED;
566 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
567 prefixlen = g_try_malloc0(MAX_PREFIX_LENGTH);
568 snprintf(prefixlen, MAX_PREFIX_LENGTH, "%d", net_info->PrefixLen6);
569 *subnet_mask = prefixlen;
571 *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask,
574 if (*subnet_mask == NULL)
575 return CONNECTION_ERROR_OUT_OF_MEMORY;
577 return CONNECTION_ERROR_NONE;
580 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
581 connection_address_family_e address_family, char** gateway_address)
583 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
585 if (!(_connection_libnet_check_profile_validity(profile)) ||
586 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
587 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
588 gateway_address == NULL) {
589 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
590 return CONNECTION_ERROR_INVALID_PARAMETER;
593 net_profile_info_t *profile_info = profile;
594 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
595 if (net_info == NULL)
596 return CONNECTION_ERROR_OPERATION_FAILED;
598 if(address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
599 *gateway_address = __profile_convert_ip_to_string(
600 &net_info->GatewayAddr6, address_family);
602 *gateway_address = __profile_convert_ip_to_string(
603 &net_info->GatewayAddr, address_family);
605 if (*gateway_address == NULL)
606 return CONNECTION_ERROR_OUT_OF_MEMORY;
608 return CONNECTION_ERROR_NONE;
611 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
612 connection_address_family_e address_family, char** dns_address)
614 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
616 if (!(_connection_libnet_check_profile_validity(profile)) ||
617 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
618 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
619 dns_address == NULL ||
621 order > NET_DNS_ADDR_MAX) {
622 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
623 return CONNECTION_ERROR_INVALID_PARAMETER;
626 net_profile_info_t *profile_info = profile;
627 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
628 if (net_info == NULL)
629 return CONNECTION_ERROR_OPERATION_FAILED;
631 if(address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
632 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
634 else if(address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
635 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1],
638 CONNECTION_LOG(CONNECTION_ERROR, "Invalid address family\n");
640 if (*dns_address == NULL)
641 return CONNECTION_ERROR_OUT_OF_MEMORY;
643 return CONNECTION_ERROR_NONE;
646 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e* type)
648 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
650 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
651 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
652 return CONNECTION_ERROR_INVALID_PARAMETER;
656 net_profile_info_t *profile_info = profile;
657 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
658 if (net_info == NULL)
659 return CONNECTION_ERROR_OPERATION_FAILED;
661 if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
662 proxy = __profile_get_ethernet_proxy();
664 *type = CONNECTION_PROXY_TYPE_DIRECT;
666 *type = CONNECTION_PROXY_TYPE_MANUAL;
668 return CONNECTION_ERROR_NONE;
671 switch (net_info->ProxyMethod) {
672 case NET_PROXY_TYPE_DIRECT:
673 *type = CONNECTION_PROXY_TYPE_DIRECT;
675 case NET_PROXY_TYPE_AUTO:
676 *type = CONNECTION_PROXY_TYPE_AUTO;
678 case NET_PROXY_TYPE_MANUAL:
679 *type = CONNECTION_PROXY_TYPE_MANUAL;
681 case NET_PROXY_TYPE_UNKNOWN:
683 return CONNECTION_ERROR_OPERATION_FAILED;
686 return CONNECTION_ERROR_NONE;
689 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
690 connection_address_family_e address_family, char** proxy_address)
692 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
694 if (!(_connection_libnet_check_profile_validity(profile)) ||
695 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
696 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
697 proxy_address == NULL) {
698 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
699 return CONNECTION_ERROR_INVALID_PARAMETER;
702 net_profile_info_t *profile_info = profile;
703 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
704 if (net_info == NULL)
705 return CONNECTION_ERROR_OPERATION_FAILED;
707 *proxy_address = g_strdup(net_info->ProxyAddr);
709 if (*proxy_address == NULL)
710 return CONNECTION_ERROR_OUT_OF_MEMORY;
712 return CONNECTION_ERROR_NONE;
715 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
716 connection_address_family_e address_family, connection_ip_config_type_e type)
718 net_ip_config_type_t *profile_type = NULL;
720 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
722 if (!(_connection_libnet_check_profile_validity(profile)) ||
723 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
724 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
725 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
726 return CONNECTION_ERROR_INVALID_PARAMETER;
729 net_profile_info_t *profile_info = profile;
730 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
731 if (net_info == NULL)
732 return CONNECTION_ERROR_OPERATION_FAILED;
734 if(address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
735 profile_type = &net_info->IpConfigType ;
737 profile_type = &net_info->IpConfigType6 ;
739 if(address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
741 case CONNECTION_IP_CONFIG_TYPE_STATIC:
742 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
743 net_info->IpAddr.Data.Ipv4.s_addr = 0;
744 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
745 net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
748 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
749 *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
752 case CONNECTION_IP_CONFIG_TYPE_AUTO:
753 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
756 case CONNECTION_IP_CONFIG_TYPE_FIXED:
757 net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
760 case CONNECTION_IP_CONFIG_TYPE_NONE:
761 *profile_type = NET_IP_CONFIG_TYPE_OFF;
765 return CONNECTION_ERROR_INVALID_PARAMETER;
769 case CONNECTION_IP_CONFIG_TYPE_STATIC:
770 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
771 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
772 net_info->PrefixLen6 = 0 ;
773 inet_pton(AF_INET6, "::",
774 &net_info->GatewayAddr6.Data.Ipv6);
777 case CONNECTION_IP_CONFIG_TYPE_AUTO:
778 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
781 case CONNECTION_IP_CONFIG_TYPE_NONE:
782 *profile_type = NET_IP_CONFIG_TYPE_OFF;
786 return CONNECTION_ERROR_INVALID_PARAMETER;
790 return CONNECTION_ERROR_NONE;
793 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
794 connection_address_family_e address_family, const char* ip_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 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
802 return CONNECTION_ERROR_INVALID_PARAMETER;
805 net_profile_info_t *profile_info = profile;
806 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
807 if (net_info == NULL)
808 return CONNECTION_ERROR_OPERATION_FAILED;
810 if(address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
811 if (ip_address == NULL)
812 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
813 else if (inet_pton(AF_INET6, ip_address,
814 &net_info->IpAddr6.Data.Ipv6) < 1)
815 return CONNECTION_ERROR_INVALID_PARAMETER;
817 if (ip_address == NULL)
818 net_info->IpAddr.Data.Ipv4.s_addr = 0;
819 else if (inet_pton(AF_INET, ip_address,
820 &net_info->IpAddr.Data.Ipv4) < 1)
821 return CONNECTION_ERROR_INVALID_PARAMETER;
824 return CONNECTION_ERROR_NONE;
827 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
828 connection_address_family_e address_family, const char* subnet_mask)
830 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
832 if (!(_connection_libnet_check_profile_validity(profile)) ||
833 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
834 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
835 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
836 return CONNECTION_ERROR_INVALID_PARAMETER;
839 net_profile_info_t *profile_info = profile;
840 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
841 if (net_info == NULL)
842 return CONNECTION_ERROR_OPERATION_FAILED;
844 if(address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
845 if (subnet_mask == NULL)
846 net_info->PrefixLen6 = 0 ;
848 net_info->PrefixLen6 = atoi(subnet_mask) ;
850 if (subnet_mask == NULL)
851 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
852 else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4) < 1 )
853 return CONNECTION_ERROR_INVALID_PARAMETER;
856 return CONNECTION_ERROR_NONE;
859 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
860 connection_address_family_e address_family, const char* gateway_address)
862 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
864 if (!(_connection_libnet_check_profile_validity(profile)) ||
865 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
866 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
867 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
868 return CONNECTION_ERROR_INVALID_PARAMETER;
871 net_profile_info_t *profile_info = profile;
872 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
873 if (net_info == NULL)
874 return CONNECTION_ERROR_OPERATION_FAILED;
876 if(address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
877 if (gateway_address == NULL)
878 inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
879 else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1)
880 return CONNECTION_ERROR_INVALID_PARAMETER;
882 if (gateway_address == NULL)
883 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
884 else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1)
885 return CONNECTION_ERROR_INVALID_PARAMETER;
888 return CONNECTION_ERROR_NONE;
891 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
892 connection_address_family_e address_family, const char* dns_address)
894 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
896 if (!(_connection_libnet_check_profile_validity(profile)) ||
897 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
898 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
900 order > NET_DNS_ADDR_MAX) {
901 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
902 return CONNECTION_ERROR_INVALID_PARAMETER;
905 net_profile_info_t *profile_info = profile;
906 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
907 if (net_info == NULL)
908 return CONNECTION_ERROR_OPERATION_FAILED;
910 if(address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
911 net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
912 if (dns_address == NULL)
913 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
914 else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1)
915 return CONNECTION_ERROR_INVALID_PARAMETER;
916 if (net_info->DnsCount6 < order)
917 net_info->DnsCount6 = order;
919 net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
920 if (dns_address == NULL)
921 net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
922 else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1)
923 return CONNECTION_ERROR_INVALID_PARAMETER;
924 if (net_info->DnsCount < order)
925 net_info->DnsCount = order;
928 return CONNECTION_ERROR_NONE;
931 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
933 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
935 if (!(_connection_libnet_check_profile_validity(profile))) {
936 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
937 return CONNECTION_ERROR_INVALID_PARAMETER;
940 net_profile_info_t *profile_info = profile;
941 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
942 if (net_info == NULL)
943 return CONNECTION_ERROR_OPERATION_FAILED;
946 case CONNECTION_PROXY_TYPE_DIRECT:
947 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
949 case CONNECTION_PROXY_TYPE_AUTO:
950 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
952 case CONNECTION_PROXY_TYPE_MANUAL:
953 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
956 return CONNECTION_ERROR_INVALID_PARAMETER;
959 return CONNECTION_ERROR_NONE;
962 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
963 connection_address_family_e address_family, const char* proxy_address)
965 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
967 if (!(_connection_libnet_check_profile_validity(profile)) ||
968 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
969 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
970 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
971 return CONNECTION_ERROR_INVALID_PARAMETER;
974 net_profile_info_t *profile_info = profile;
975 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
976 if (net_info == NULL)
977 return CONNECTION_ERROR_OPERATION_FAILED;
979 if (proxy_address == NULL)
980 net_info->ProxyAddr[0] = '\0';
982 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
984 return CONNECTION_ERROR_NONE;
987 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
988 connection_profile_state_changed_cb callback, void* user_data)
990 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
992 if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
993 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
994 return CONNECTION_ERROR_INVALID_PARAMETER;
997 if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
998 return CONNECTION_ERROR_NONE;
1000 return CONNECTION_ERROR_OPERATION_FAILED;
1003 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
1005 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1007 if (!(_connection_libnet_check_profile_cb_validity(profile))) {
1008 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1009 return CONNECTION_ERROR_INVALID_PARAMETER;
1012 if (_connection_libnet_remove_from_profile_cb_list(profile) != true)
1013 return CONNECTION_ERROR_INVALID_PARAMETER;
1015 return CONNECTION_ERROR_NONE;
1019 /* Wi-Fi profile *************************************************************/
1020 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
1022 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1024 if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
1025 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1026 return CONNECTION_ERROR_INVALID_PARAMETER;
1029 net_profile_info_t *profile_info = profile;
1031 if (profile_info->profile_type != NET_DEVICE_WIFI)
1032 return CONNECTION_ERROR_INVALID_PARAMETER;
1034 *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
1036 return CONNECTION_ERROR_OUT_OF_MEMORY;
1038 return CONNECTION_ERROR_NONE;
1041 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
1043 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1045 if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
1046 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1047 return CONNECTION_ERROR_INVALID_PARAMETER;
1050 net_profile_info_t *profile_info = profile;
1052 if (profile_info->profile_type != NET_DEVICE_WIFI)
1053 return CONNECTION_ERROR_INVALID_PARAMETER;
1055 *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
1057 return CONNECTION_ERROR_OUT_OF_MEMORY;
1059 return CONNECTION_ERROR_NONE;
1062 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1064 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1066 if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
1067 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1068 return CONNECTION_ERROR_INVALID_PARAMETER;
1071 net_profile_info_t *profile_info = profile;
1073 if (profile_info->profile_type != NET_DEVICE_WIFI)
1074 return CONNECTION_ERROR_INVALID_PARAMETER;
1076 *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1078 return CONNECTION_ERROR_NONE;
1081 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1083 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1085 if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
1086 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1087 return CONNECTION_ERROR_INVALID_PARAMETER;
1090 net_profile_info_t *profile_info = profile;
1092 if (profile_info->profile_type != NET_DEVICE_WIFI)
1093 return CONNECTION_ERROR_INVALID_PARAMETER;
1095 *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1097 return CONNECTION_ERROR_NONE;
1100 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1102 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1104 if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
1105 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1106 return CONNECTION_ERROR_INVALID_PARAMETER;
1109 net_profile_info_t *profile_info = profile;
1111 if (profile_info->profile_type != NET_DEVICE_WIFI)
1112 return CONNECTION_ERROR_INVALID_PARAMETER;
1114 *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate;
1116 return CONNECTION_ERROR_NONE;
1119 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e* type)
1121 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1123 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1124 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1125 return CONNECTION_ERROR_INVALID_PARAMETER;
1128 net_profile_info_t *profile_info = profile;
1130 if (profile_info->profile_type != NET_DEVICE_WIFI)
1131 return CONNECTION_ERROR_INVALID_PARAMETER;
1133 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1134 case WLAN_SEC_MODE_NONE:
1135 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1137 case WLAN_SEC_MODE_WEP:
1138 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1140 case WLAN_SEC_MODE_IEEE8021X:
1141 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1143 case WLAN_SEC_MODE_WPA_PSK:
1144 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1146 case WLAN_SEC_MODE_WPA2_PSK:
1147 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1150 return CONNECTION_ERROR_OPERATION_FAILED;
1153 return CONNECTION_ERROR_NONE;
1156 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e* type)
1158 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1160 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1161 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1162 return CONNECTION_ERROR_INVALID_PARAMETER;
1165 net_profile_info_t *profile_info = profile;
1167 if (profile_info->profile_type != NET_DEVICE_WIFI)
1168 return CONNECTION_ERROR_INVALID_PARAMETER;
1170 switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1171 case WLAN_ENC_MODE_NONE:
1172 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1174 case WLAN_ENC_MODE_WEP:
1175 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1177 case WLAN_ENC_MODE_TKIP:
1178 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1180 case WLAN_ENC_MODE_AES:
1181 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1183 case WLAN_ENC_MODE_TKIP_AES_MIXED:
1184 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1187 return CONNECTION_ERROR_OPERATION_FAILED;
1190 return CONNECTION_ERROR_NONE;
1193 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1195 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1197 if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1198 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1199 return CONNECTION_ERROR_INVALID_PARAMETER;
1202 net_profile_info_t *profile_info = profile;
1204 if (profile_info->profile_type != NET_DEVICE_WIFI)
1205 return CONNECTION_ERROR_INVALID_PARAMETER;
1207 if (profile_info->Favourite) {
1209 return CONNECTION_ERROR_NONE;
1212 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1213 case WLAN_SEC_MODE_NONE:
1216 case WLAN_SEC_MODE_WEP:
1217 case WLAN_SEC_MODE_IEEE8021X:
1218 case WLAN_SEC_MODE_WPA_PSK:
1219 case WLAN_SEC_MODE_WPA2_PSK:
1223 return CONNECTION_ERROR_OPERATION_FAILED;
1226 return CONNECTION_ERROR_NONE;
1229 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1231 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1233 if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1234 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1235 return CONNECTION_ERROR_INVALID_PARAMETER;
1238 net_profile_info_t *profile_info = profile;
1240 if (profile_info->profile_type != NET_DEVICE_WIFI)
1241 return CONNECTION_ERROR_INVALID_PARAMETER;
1243 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1244 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1246 return CONNECTION_ERROR_NONE;
1249 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1251 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1253 if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1254 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1255 return CONNECTION_ERROR_INVALID_PARAMETER;
1258 net_profile_info_t *profile_info = profile;
1260 if (profile_info->profile_type != NET_DEVICE_WIFI)
1261 return CONNECTION_ERROR_INVALID_PARAMETER;
1263 if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1268 return CONNECTION_ERROR_NONE;
1272 /* Cellular profile **********************************************************/
1273 EXPORT_API int connection_profile_get_cellular_network_type(connection_profile_h profile, connection_cellular_network_type_e* type)
1275 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1277 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1278 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1279 return CONNECTION_ERROR_INVALID_PARAMETER;
1283 net_profile_info_t *profile_info = profile;
1285 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1286 return CONNECTION_ERROR_INVALID_PARAMETER;
1288 if (vconf_get_int(VCONFKEY_TELEPHONY_SVC_ACT, &network_type)) {
1289 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed\n");
1290 return CONNECTION_ERROR_OPERATION_FAILED;
1293 CONNECTION_LOG(CONNECTION_INFO, "Cellular network type = %d\n", network_type);
1295 switch (network_type) {
1296 case VCONFKEY_TELEPHONY_SVC_ACT_NONE:
1297 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UNKNOWN;
1299 case VCONFKEY_TELEPHONY_SVC_ACT_GPRS:
1300 *type = CONNECTION_CELLULAR_NETWORK_TYPE_GPRS;
1302 case VCONFKEY_TELEPHONY_SVC_ACT_EGPRS:
1303 *type = CONNECTION_CELLULAR_NETWORK_TYPE_EDGE;
1305 case VCONFKEY_TELEPHONY_SVC_ACT_UMTS:
1306 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UMTS;
1309 return CONNECTION_ERROR_OPERATION_FAILED;
1312 return CONNECTION_ERROR_NONE;
1315 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1316 connection_cellular_service_type_e* type)
1318 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1320 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1321 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1322 return CONNECTION_ERROR_INVALID_PARAMETER;
1325 net_profile_info_t *profile_info = profile;
1327 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1328 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type Passed\n");
1329 return CONNECTION_ERROR_INVALID_PARAMETER;
1332 *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1334 if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1335 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed\n");
1336 return CONNECTION_ERROR_OPERATION_FAILED;
1339 return CONNECTION_ERROR_NONE;
1342 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1344 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1346 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1347 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1348 return CONNECTION_ERROR_INVALID_PARAMETER;
1351 net_profile_info_t *profile_info = profile;
1353 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1354 return CONNECTION_ERROR_INVALID_PARAMETER;
1356 *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1358 return CONNECTION_ERROR_OUT_OF_MEMORY;
1360 return CONNECTION_ERROR_NONE;
1363 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1364 connection_cellular_auth_type_e* type, char** user_name, char** password)
1366 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1368 if (!(_connection_libnet_check_profile_validity(profile)) ||
1369 type == NULL || user_name == NULL || password == NULL) {
1370 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1371 return CONNECTION_ERROR_INVALID_PARAMETER;
1374 net_profile_info_t *profile_info = profile;
1376 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1377 return CONNECTION_ERROR_INVALID_PARAMETER;
1379 switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1380 case NET_PDP_AUTH_NONE:
1381 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1383 case NET_PDP_AUTH_PAP:
1384 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1386 case NET_PDP_AUTH_CHAP:
1387 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1390 return CONNECTION_ERROR_OPERATION_FAILED;
1393 *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1394 if (*user_name == NULL)
1395 return CONNECTION_ERROR_OUT_OF_MEMORY;
1397 *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1398 if (*password == NULL) {
1400 return CONNECTION_ERROR_OUT_OF_MEMORY;
1403 return CONNECTION_ERROR_NONE;
1406 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1408 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1410 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1411 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1412 return CONNECTION_ERROR_INVALID_PARAMETER;
1415 net_profile_info_t *profile_info = profile;
1417 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1418 return CONNECTION_ERROR_INVALID_PARAMETER;
1420 *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1421 if (*home_url == NULL)
1422 return CONNECTION_ERROR_OUT_OF_MEMORY;
1424 return CONNECTION_ERROR_NONE;
1427 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1429 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1431 if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1432 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1433 return CONNECTION_ERROR_INVALID_PARAMETER;
1436 net_profile_info_t *profile_info = profile;
1438 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1439 return CONNECTION_ERROR_INVALID_PARAMETER;
1441 if (profile_info->ProfileInfo.Pdp.Roaming)
1444 *is_roaming = false;
1446 return CONNECTION_ERROR_NONE;
1449 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
1451 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1453 if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == 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 if (profile_info->ProfileInfo.Pdp.Hidden)
1470 return CONNECTION_ERROR_NONE;
1473 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
1475 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1477 if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
1478 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1479 return CONNECTION_ERROR_INVALID_PARAMETER;
1482 net_profile_info_t *profile_info = profile;
1484 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1485 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1486 return CONNECTION_ERROR_INVALID_PARAMETER;
1489 if (profile_info->ProfileInfo.Pdp.Editable)
1490 *is_editable = true;
1492 *is_editable = false;
1494 return CONNECTION_ERROR_NONE;
1497 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
1499 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1501 if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
1502 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1503 return CONNECTION_ERROR_INVALID_PARAMETER;
1506 net_profile_info_t *profile_info = profile;
1508 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1509 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1510 return CONNECTION_ERROR_INVALID_PARAMETER;
1513 if (profile_info->ProfileInfo.Pdp.DefaultConn)
1516 *is_default = false;
1518 return CONNECTION_ERROR_NONE;
1521 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
1522 connection_cellular_service_type_e service_type)
1524 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1526 if (!(_connection_libnet_check_profile_validity(profile))) {
1527 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1528 return CONNECTION_ERROR_INVALID_PARAMETER;
1531 net_profile_info_t *profile_info = profile;
1533 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1534 return CONNECTION_ERROR_INVALID_PARAMETER;
1536 switch (service_type) {
1537 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1538 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1540 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1541 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1543 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1544 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1546 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1547 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1549 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1550 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1552 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1553 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1555 case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1557 return CONNECTION_ERROR_INVALID_PARAMETER;
1560 return CONNECTION_ERROR_NONE;
1563 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1565 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1567 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1568 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1569 return CONNECTION_ERROR_INVALID_PARAMETER;
1572 net_profile_info_t *profile_info = profile;
1574 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1575 return CONNECTION_ERROR_INVALID_PARAMETER;
1577 g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1579 return CONNECTION_ERROR_NONE;
1582 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1583 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1585 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1587 if (!(_connection_libnet_check_profile_validity(profile)) ||
1588 user_name == NULL || password == NULL) {
1589 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1590 return CONNECTION_ERROR_INVALID_PARAMETER;
1593 net_profile_info_t *profile_info = profile;
1595 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1596 return CONNECTION_ERROR_INVALID_PARAMETER;
1599 case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1600 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1602 case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1603 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1605 case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1606 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1609 return CONNECTION_ERROR_INVALID_PARAMETER;
1612 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1613 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1615 return CONNECTION_ERROR_NONE;
1618 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1620 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1622 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1623 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1624 return CONNECTION_ERROR_INVALID_PARAMETER;
1627 net_profile_info_t *profile_info = profile;
1629 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1630 return CONNECTION_ERROR_INVALID_PARAMETER;
1632 g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1634 return CONNECTION_ERROR_NONE;