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 if ((type != CONNECTION_PROFILE_TYPE_CELLULAR &&
211 type != CONNECTION_PROFILE_TYPE_WIFI) || profile == NULL) {
212 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
213 return CONNECTION_ERROR_INVALID_PARAMETER;
216 net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
217 if (profile_info == NULL)
218 return CONNECTION_ERROR_OUT_OF_MEMORY;
221 case CONNECTION_PROFILE_TYPE_CELLULAR:
222 if (keyword == NULL) {
223 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
224 g_free(profile_info);
225 return CONNECTION_ERROR_INVALID_PARAMETER;
227 __profile_init_cellular_profile(profile_info, keyword);
229 case CONNECTION_PROFILE_TYPE_WIFI:
230 __profile_init_wifi_profile(profile_info);
236 *profile = (connection_profile_h)profile_info;
237 _connection_libnet_add_to_profile_list(*profile);
239 return CONNECTION_ERROR_NONE;
242 EXPORT_API int connection_profile_destroy(connection_profile_h profile)
244 if (!(_connection_libnet_check_profile_validity(profile))) {
245 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
246 return CONNECTION_ERROR_INVALID_PARAMETER;
249 _connection_libnet_remove_from_profile_list(profile);
251 return CONNECTION_ERROR_NONE;
254 EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
256 if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
257 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
258 return CONNECTION_ERROR_INVALID_PARAMETER;
261 *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
262 if (*cloned_profile == NULL)
263 return CONNECTION_ERROR_OUT_OF_MEMORY;
265 memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
266 _connection_libnet_add_to_profile_list(*cloned_profile);
268 return CONNECTION_ERROR_NONE;
271 EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
273 if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
274 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
275 return CONNECTION_ERROR_INVALID_PARAMETER;
278 net_profile_info_t *profile_info = profile;
280 char *prof_id = strrchr(profile_info->ProfileName, '/');
282 return CONNECTION_ERROR_INVALID_PARAMETER;
285 *profile_id = g_strdup(prof_id);
287 if (*profile_id == NULL)
288 return CONNECTION_ERROR_OUT_OF_MEMORY;
290 return CONNECTION_ERROR_NONE;
293 EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
295 if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
296 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
297 return CONNECTION_ERROR_INVALID_PARAMETER;
300 net_profile_info_t *profile_info = profile;
302 switch (profile_info->profile_type) {
303 case NET_DEVICE_CELLULAR:
304 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
306 case NET_DEVICE_WIFI:
307 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
309 case NET_DEVICE_ETHERNET:
310 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName);
312 case NET_DEVICE_BLUETOOTH: {
313 char *bt_name = strrchr(profile_info->ProfileName, '/');
315 return CONNECTION_ERROR_INVALID_PARAMETER;
318 *profile_name = g_strdup(bt_name);
321 return CONNECTION_ERROR_INVALID_PARAMETER;
324 if (*profile_name == NULL)
325 return CONNECTION_ERROR_OUT_OF_MEMORY;
327 return CONNECTION_ERROR_NONE;
330 EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e* type)
332 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
333 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
334 return CONNECTION_ERROR_INVALID_PARAMETER;
337 net_profile_info_t *profile_info = profile;
339 switch (profile_info->profile_type) {
340 case NET_DEVICE_CELLULAR:
341 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
343 case NET_DEVICE_WIFI:
344 *type = CONNECTION_PROFILE_TYPE_WIFI;
346 case NET_DEVICE_ETHERNET:
347 *type = CONNECTION_PROFILE_TYPE_ETHERNET;
349 case NET_DEVICE_BLUETOOTH:
350 *type = CONNECTION_PROFILE_TYPE_BT;
353 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type\n");
354 return CONNECTION_ERROR_OPERATION_FAILED;
357 return CONNECTION_ERROR_NONE;
360 EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
362 if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
363 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
364 return CONNECTION_ERROR_INVALID_PARAMETER;
367 net_profile_info_t *profile_info = profile;
368 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
369 if (net_info == NULL)
370 return CONNECTION_ERROR_INVALID_PARAMETER;
372 *interface_name = g_strdup(net_info->DevName);
373 if (*interface_name == NULL)
374 return CONNECTION_ERROR_OUT_OF_MEMORY;
376 return CONNECTION_ERROR_NONE;
379 EXPORT_API int connection_profile_refresh(connection_profile_h profile)
382 if (!(_connection_libnet_check_profile_validity(profile))) {
383 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
384 return CONNECTION_ERROR_INVALID_PARAMETER;
387 net_profile_info_t profile_info_local;
388 net_profile_info_t *profile_info = profile;
390 rv = net_get_profile_info(profile_info->ProfileName, &profile_info_local);
391 if (rv == NET_ERR_ACCESS_DENIED) {
392 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
393 return CONNECTION_ERROR_PERMISSION_DENIED;
394 } else if (rv != NET_ERR_NONE) {
395 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile information");
396 return CONNECTION_ERROR_OPERATION_FAILED;
399 memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
401 return CONNECTION_ERROR_NONE;
404 EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
406 if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
407 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
408 return CONNECTION_ERROR_INVALID_PARAMETER;
411 net_profile_info_t *profile_info = profile;
412 *state = _profile_convert_to_cp_state(profile_info->ProfileState);
414 return CONNECTION_ERROR_OPERATION_FAILED;
416 return CONNECTION_ERROR_NONE;
419 EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
420 connection_address_family_e address_family, connection_ip_config_type_e* type)
422 net_ip_config_type_t profile_type;
424 if (!(_connection_libnet_check_profile_validity(profile)) ||
425 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
426 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
428 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
429 return CONNECTION_ERROR_INVALID_PARAMETER;
432 net_profile_info_t *profile_info = profile;
433 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
434 if (net_info == NULL)
435 return CONNECTION_ERROR_OPERATION_FAILED;
437 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
438 profile_type = net_info->IpConfigType;
440 profile_type = net_info->IpConfigType6;
442 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
443 switch (profile_type) {
444 case NET_IP_CONFIG_TYPE_STATIC:
445 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
448 case NET_IP_CONFIG_TYPE_DYNAMIC:
449 *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
452 case NET_IP_CONFIG_TYPE_AUTO_IP:
453 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
456 case NET_IP_CONFIG_TYPE_FIXED:
457 *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
460 case NET_IP_CONFIG_TYPE_OFF:
461 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
464 return CONNECTION_ERROR_OPERATION_FAILED;
467 switch (profile_type) {
468 case NET_IP_CONFIG_TYPE_STATIC:
469 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
472 case NET_IP_CONFIG_TYPE_AUTO_IP:
473 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
476 case NET_IP_CONFIG_TYPE_OFF:
477 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
481 return CONNECTION_ERROR_OPERATION_FAILED;
486 return CONNECTION_ERROR_NONE;
489 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
490 connection_address_family_e address_family, char** ip_address)
492 if (!(_connection_libnet_check_profile_validity(profile)) ||
493 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
494 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
495 ip_address == NULL) {
496 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
497 return CONNECTION_ERROR_INVALID_PARAMETER;
500 net_profile_info_t *profile_info = profile;
501 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
502 if (net_info == NULL)
503 return CONNECTION_ERROR_OPERATION_FAILED;
505 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
506 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr6,
509 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
512 if (*ip_address == NULL)
513 return CONNECTION_ERROR_OUT_OF_MEMORY;
515 return CONNECTION_ERROR_NONE;
518 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
519 connection_address_family_e address_family, char** subnet_mask)
523 if (!(_connection_libnet_check_profile_validity(profile)) ||
524 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
525 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
526 subnet_mask == NULL) {
527 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
528 return CONNECTION_ERROR_INVALID_PARAMETER;
531 net_profile_info_t *profile_info = profile;
532 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
533 if (net_info == NULL)
534 return CONNECTION_ERROR_OPERATION_FAILED;
536 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
537 prefixlen = g_try_malloc0(MAX_PREFIX_LENGTH);
538 snprintf(prefixlen, MAX_PREFIX_LENGTH, "%d", net_info->PrefixLen6);
539 *subnet_mask = prefixlen;
541 *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask,
544 if (*subnet_mask == NULL)
545 return CONNECTION_ERROR_OUT_OF_MEMORY;
547 return CONNECTION_ERROR_NONE;
550 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
551 connection_address_family_e address_family, char** gateway_address)
553 if (!(_connection_libnet_check_profile_validity(profile)) ||
554 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
555 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
556 gateway_address == 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 *gateway_address = __profile_convert_ip_to_string(
568 &net_info->GatewayAddr6, address_family);
570 *gateway_address = __profile_convert_ip_to_string(
571 &net_info->GatewayAddr, address_family);
573 if (*gateway_address == NULL)
574 return CONNECTION_ERROR_OUT_OF_MEMORY;
576 return CONNECTION_ERROR_NONE;
579 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
580 connection_address_family_e address_family, char** dns_address)
582 if (!(_connection_libnet_check_profile_validity(profile)) ||
583 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
584 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
585 dns_address == NULL ||
587 order > NET_DNS_ADDR_MAX) {
588 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
589 return CONNECTION_ERROR_INVALID_PARAMETER;
592 net_profile_info_t *profile_info = profile;
593 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
594 if (net_info == NULL)
595 return CONNECTION_ERROR_OPERATION_FAILED;
597 if(address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
598 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
600 else if(address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
601 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1],
604 CONNECTION_LOG(CONNECTION_ERROR, "Invalid address family\n");
606 if (*dns_address == NULL)
607 return CONNECTION_ERROR_OUT_OF_MEMORY;
609 return CONNECTION_ERROR_NONE;
612 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e* type)
614 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
615 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
616 return CONNECTION_ERROR_INVALID_PARAMETER;
620 net_profile_info_t *profile_info = profile;
621 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
622 if (net_info == NULL)
623 return CONNECTION_ERROR_OPERATION_FAILED;
625 if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
626 proxy = __profile_get_ethernet_proxy();
628 *type = CONNECTION_PROXY_TYPE_DIRECT;
630 *type = CONNECTION_PROXY_TYPE_MANUAL;
632 return CONNECTION_ERROR_NONE;
635 switch (net_info->ProxyMethod) {
636 case NET_PROXY_TYPE_DIRECT:
637 *type = CONNECTION_PROXY_TYPE_DIRECT;
639 case NET_PROXY_TYPE_AUTO:
640 *type = CONNECTION_PROXY_TYPE_AUTO;
642 case NET_PROXY_TYPE_MANUAL:
643 *type = CONNECTION_PROXY_TYPE_MANUAL;
645 case NET_PROXY_TYPE_UNKNOWN:
647 return CONNECTION_ERROR_OPERATION_FAILED;
650 return CONNECTION_ERROR_NONE;
653 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
654 connection_address_family_e address_family, char** proxy_address)
656 if (!(_connection_libnet_check_profile_validity(profile)) ||
657 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
658 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
659 proxy_address == NULL) {
660 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
661 return CONNECTION_ERROR_INVALID_PARAMETER;
664 net_profile_info_t *profile_info = profile;
665 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
666 if (net_info == NULL)
667 return CONNECTION_ERROR_OPERATION_FAILED;
669 *proxy_address = g_strdup(net_info->ProxyAddr);
671 if (*proxy_address == NULL)
672 return CONNECTION_ERROR_OUT_OF_MEMORY;
674 return CONNECTION_ERROR_NONE;
677 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
678 connection_address_family_e address_family, connection_ip_config_type_e type)
680 net_ip_config_type_t *profile_type = NULL;
682 if (!(_connection_libnet_check_profile_validity(profile)) ||
683 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
684 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
685 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
686 return CONNECTION_ERROR_INVALID_PARAMETER;
689 net_profile_info_t *profile_info = profile;
690 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
691 if (net_info == NULL)
692 return CONNECTION_ERROR_OPERATION_FAILED;
694 if(address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
695 profile_type = &net_info->IpConfigType ;
697 profile_type = &net_info->IpConfigType6 ;
699 if(address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
701 case CONNECTION_IP_CONFIG_TYPE_STATIC:
702 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
703 net_info->IpAddr.Data.Ipv4.s_addr = 0;
704 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
705 net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
708 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
709 *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
712 case CONNECTION_IP_CONFIG_TYPE_AUTO:
713 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
716 case CONNECTION_IP_CONFIG_TYPE_FIXED:
717 net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
720 case CONNECTION_IP_CONFIG_TYPE_NONE:
721 *profile_type = NET_IP_CONFIG_TYPE_OFF;
725 return CONNECTION_ERROR_INVALID_PARAMETER;
729 case CONNECTION_IP_CONFIG_TYPE_STATIC:
730 *profile_type = NET_IP_CONFIG_TYPE_STATIC;
731 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
732 net_info->PrefixLen6 = 0 ;
733 inet_pton(AF_INET6, "::",
734 &net_info->GatewayAddr6.Data.Ipv6);
737 case CONNECTION_IP_CONFIG_TYPE_AUTO:
738 *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
741 case CONNECTION_IP_CONFIG_TYPE_NONE:
742 *profile_type = NET_IP_CONFIG_TYPE_OFF;
746 return CONNECTION_ERROR_INVALID_PARAMETER;
750 return CONNECTION_ERROR_NONE;
753 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
754 connection_address_family_e address_family, const char* ip_address)
756 if (!(_connection_libnet_check_profile_validity(profile)) ||
757 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
758 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
759 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
760 return CONNECTION_ERROR_INVALID_PARAMETER;
763 net_profile_info_t *profile_info = profile;
764 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
765 if (net_info == NULL)
766 return CONNECTION_ERROR_OPERATION_FAILED;
768 if(address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
769 if (ip_address == NULL)
770 inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
771 else if (inet_pton(AF_INET6, ip_address,
772 &net_info->IpAddr6.Data.Ipv6) < 1)
773 return CONNECTION_ERROR_INVALID_PARAMETER;
775 if (ip_address == NULL)
776 net_info->IpAddr.Data.Ipv4.s_addr = 0;
777 else if (inet_pton(AF_INET, ip_address,
778 &net_info->IpAddr.Data.Ipv4) < 1)
779 return CONNECTION_ERROR_INVALID_PARAMETER;
782 return CONNECTION_ERROR_NONE;
785 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
786 connection_address_family_e address_family, const char* subnet_mask)
788 if (!(_connection_libnet_check_profile_validity(profile)) ||
789 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
790 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
791 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
792 return CONNECTION_ERROR_INVALID_PARAMETER;
795 net_profile_info_t *profile_info = profile;
796 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
797 if (net_info == NULL)
798 return CONNECTION_ERROR_OPERATION_FAILED;
800 if(address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
801 if (subnet_mask == NULL)
802 net_info->PrefixLen6 = 0 ;
804 net_info->PrefixLen6 = atoi(subnet_mask) ;
806 if (subnet_mask == NULL)
807 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
808 else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4) < 1 )
809 return CONNECTION_ERROR_INVALID_PARAMETER;
812 return CONNECTION_ERROR_NONE;
815 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
816 connection_address_family_e address_family, const char* gateway_address)
818 if (!(_connection_libnet_check_profile_validity(profile)) ||
819 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
820 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
821 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
822 return CONNECTION_ERROR_INVALID_PARAMETER;
825 net_profile_info_t *profile_info = profile;
826 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
827 if (net_info == NULL)
828 return CONNECTION_ERROR_OPERATION_FAILED;
830 if(address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
831 if (gateway_address == NULL)
832 inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
833 else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1)
834 return CONNECTION_ERROR_INVALID_PARAMETER;
836 if (gateway_address == NULL)
837 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
838 else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1)
839 return CONNECTION_ERROR_INVALID_PARAMETER;
842 return CONNECTION_ERROR_NONE;
845 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
846 connection_address_family_e address_family, const char* dns_address)
848 if (!(_connection_libnet_check_profile_validity(profile)) ||
849 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
850 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
852 order > NET_DNS_ADDR_MAX) {
853 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
854 return CONNECTION_ERROR_INVALID_PARAMETER;
857 net_profile_info_t *profile_info = profile;
858 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
859 if (net_info == NULL)
860 return CONNECTION_ERROR_OPERATION_FAILED;
862 if(address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
863 net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
864 if (dns_address == NULL)
865 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
866 else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1)
867 return CONNECTION_ERROR_INVALID_PARAMETER;
868 if (net_info->DnsCount6 < order)
869 net_info->DnsCount6 = order;
871 net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
872 if (dns_address == NULL)
873 net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
874 else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1)
875 return CONNECTION_ERROR_INVALID_PARAMETER;
876 if (net_info->DnsCount < order)
877 net_info->DnsCount = order;
880 return CONNECTION_ERROR_NONE;
883 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
885 if (!(_connection_libnet_check_profile_validity(profile))) {
886 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
887 return CONNECTION_ERROR_INVALID_PARAMETER;
890 net_profile_info_t *profile_info = profile;
891 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
892 if (net_info == NULL)
893 return CONNECTION_ERROR_OPERATION_FAILED;
896 case CONNECTION_PROXY_TYPE_DIRECT:
897 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
899 case CONNECTION_PROXY_TYPE_AUTO:
900 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
902 case CONNECTION_PROXY_TYPE_MANUAL:
903 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
906 return CONNECTION_ERROR_INVALID_PARAMETER;
909 return CONNECTION_ERROR_NONE;
912 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
913 connection_address_family_e address_family, const char* proxy_address)
915 if (!(_connection_libnet_check_profile_validity(profile)) ||
916 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
917 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
918 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
919 return CONNECTION_ERROR_INVALID_PARAMETER;
922 net_profile_info_t *profile_info = profile;
923 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
924 if (net_info == NULL)
925 return CONNECTION_ERROR_OPERATION_FAILED;
927 if (proxy_address == NULL)
928 net_info->ProxyAddr[0] = '\0';
930 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
932 return CONNECTION_ERROR_NONE;
935 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
936 connection_profile_state_changed_cb callback, void* user_data)
938 if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
939 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
940 return CONNECTION_ERROR_INVALID_PARAMETER;
943 if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
944 return CONNECTION_ERROR_NONE;
946 return CONNECTION_ERROR_OPERATION_FAILED;
949 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
951 if (!(_connection_libnet_check_profile_cb_validity(profile))) {
952 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
953 return CONNECTION_ERROR_INVALID_PARAMETER;
956 if (_connection_libnet_remove_from_profile_cb_list(profile) != true)
957 return CONNECTION_ERROR_INVALID_PARAMETER;
959 return CONNECTION_ERROR_NONE;
963 /* Wi-Fi profile *************************************************************/
964 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
966 if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
967 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
968 return CONNECTION_ERROR_INVALID_PARAMETER;
971 net_profile_info_t *profile_info = profile;
973 if (profile_info->profile_type != NET_DEVICE_WIFI)
974 return CONNECTION_ERROR_INVALID_PARAMETER;
976 *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
978 return CONNECTION_ERROR_OUT_OF_MEMORY;
980 return CONNECTION_ERROR_NONE;
983 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
985 if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
986 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
987 return CONNECTION_ERROR_INVALID_PARAMETER;
990 net_profile_info_t *profile_info = profile;
992 if (profile_info->profile_type != NET_DEVICE_WIFI)
993 return CONNECTION_ERROR_INVALID_PARAMETER;
995 *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
997 return CONNECTION_ERROR_OUT_OF_MEMORY;
999 return CONNECTION_ERROR_NONE;
1002 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1004 if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
1005 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1006 return CONNECTION_ERROR_INVALID_PARAMETER;
1009 net_profile_info_t *profile_info = profile;
1011 if (profile_info->profile_type != NET_DEVICE_WIFI)
1012 return CONNECTION_ERROR_INVALID_PARAMETER;
1014 *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1016 return CONNECTION_ERROR_NONE;
1019 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1021 if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
1022 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1023 return CONNECTION_ERROR_INVALID_PARAMETER;
1026 net_profile_info_t *profile_info = profile;
1028 if (profile_info->profile_type != NET_DEVICE_WIFI)
1029 return CONNECTION_ERROR_INVALID_PARAMETER;
1031 *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1033 return CONNECTION_ERROR_NONE;
1036 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1038 if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
1039 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1040 return CONNECTION_ERROR_INVALID_PARAMETER;
1043 net_profile_info_t *profile_info = profile;
1045 if (profile_info->profile_type != NET_DEVICE_WIFI)
1046 return CONNECTION_ERROR_INVALID_PARAMETER;
1048 *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate;
1050 return CONNECTION_ERROR_NONE;
1053 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e* type)
1055 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1056 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1057 return CONNECTION_ERROR_INVALID_PARAMETER;
1060 net_profile_info_t *profile_info = profile;
1062 if (profile_info->profile_type != NET_DEVICE_WIFI)
1063 return CONNECTION_ERROR_INVALID_PARAMETER;
1065 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1066 case WLAN_SEC_MODE_NONE:
1067 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1069 case WLAN_SEC_MODE_WEP:
1070 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1072 case WLAN_SEC_MODE_IEEE8021X:
1073 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1075 case WLAN_SEC_MODE_WPA_PSK:
1076 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1078 case WLAN_SEC_MODE_WPA2_PSK:
1079 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1082 return CONNECTION_ERROR_OPERATION_FAILED;
1085 return CONNECTION_ERROR_NONE;
1088 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e* type)
1090 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1091 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1092 return CONNECTION_ERROR_INVALID_PARAMETER;
1095 net_profile_info_t *profile_info = profile;
1097 if (profile_info->profile_type != NET_DEVICE_WIFI)
1098 return CONNECTION_ERROR_INVALID_PARAMETER;
1100 switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1101 case WLAN_ENC_MODE_NONE:
1102 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1104 case WLAN_ENC_MODE_WEP:
1105 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1107 case WLAN_ENC_MODE_TKIP:
1108 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1110 case WLAN_ENC_MODE_AES:
1111 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1113 case WLAN_ENC_MODE_TKIP_AES_MIXED:
1114 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1117 return CONNECTION_ERROR_OPERATION_FAILED;
1120 return CONNECTION_ERROR_NONE;
1123 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1125 if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1126 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1127 return CONNECTION_ERROR_INVALID_PARAMETER;
1130 net_profile_info_t *profile_info = profile;
1132 if (profile_info->profile_type != NET_DEVICE_WIFI)
1133 return CONNECTION_ERROR_INVALID_PARAMETER;
1135 if (profile_info->Favourite) {
1137 return CONNECTION_ERROR_NONE;
1140 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1141 case WLAN_SEC_MODE_NONE:
1144 case WLAN_SEC_MODE_WEP:
1145 case WLAN_SEC_MODE_IEEE8021X:
1146 case WLAN_SEC_MODE_WPA_PSK:
1147 case WLAN_SEC_MODE_WPA2_PSK:
1151 return CONNECTION_ERROR_OPERATION_FAILED;
1154 return CONNECTION_ERROR_NONE;
1157 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1159 if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1160 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1161 return CONNECTION_ERROR_INVALID_PARAMETER;
1164 net_profile_info_t *profile_info = profile;
1166 if (profile_info->profile_type != NET_DEVICE_WIFI)
1167 return CONNECTION_ERROR_INVALID_PARAMETER;
1169 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1170 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1172 return CONNECTION_ERROR_NONE;
1175 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1177 if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1178 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1179 return CONNECTION_ERROR_INVALID_PARAMETER;
1182 net_profile_info_t *profile_info = profile;
1184 if (profile_info->profile_type != NET_DEVICE_WIFI)
1185 return CONNECTION_ERROR_INVALID_PARAMETER;
1187 if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1192 return CONNECTION_ERROR_NONE;
1196 /* Cellular profile **********************************************************/
1197 EXPORT_API int connection_profile_get_cellular_network_type(connection_profile_h profile, connection_cellular_network_type_e* type)
1199 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1200 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1201 return CONNECTION_ERROR_INVALID_PARAMETER;
1205 net_profile_info_t *profile_info = profile;
1207 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1208 return CONNECTION_ERROR_INVALID_PARAMETER;
1210 if (vconf_get_int(VCONFKEY_TELEPHONY_SVC_ACT, &network_type)) {
1211 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed\n");
1212 return CONNECTION_ERROR_OPERATION_FAILED;
1215 CONNECTION_LOG(CONNECTION_INFO, "Cellular network type = %d\n", network_type);
1217 switch (network_type) {
1218 case VCONFKEY_TELEPHONY_SVC_ACT_NONE:
1219 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UNKNOWN;
1221 case VCONFKEY_TELEPHONY_SVC_ACT_GPRS:
1222 *type = CONNECTION_CELLULAR_NETWORK_TYPE_GPRS;
1224 case VCONFKEY_TELEPHONY_SVC_ACT_EGPRS:
1225 *type = CONNECTION_CELLULAR_NETWORK_TYPE_EDGE;
1227 case VCONFKEY_TELEPHONY_SVC_ACT_UMTS:
1228 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UMTS;
1231 return CONNECTION_ERROR_OPERATION_FAILED;
1234 return CONNECTION_ERROR_NONE;
1237 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1238 connection_cellular_service_type_e* type)
1240 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1241 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1242 return CONNECTION_ERROR_INVALID_PARAMETER;
1245 net_profile_info_t *profile_info = profile;
1247 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1248 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type Passed\n");
1249 return CONNECTION_ERROR_INVALID_PARAMETER;
1252 *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1254 if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1255 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed\n");
1256 return CONNECTION_ERROR_OPERATION_FAILED;
1259 return CONNECTION_ERROR_NONE;
1262 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1264 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1265 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1266 return CONNECTION_ERROR_INVALID_PARAMETER;
1269 net_profile_info_t *profile_info = profile;
1271 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1272 return CONNECTION_ERROR_INVALID_PARAMETER;
1274 *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1276 return CONNECTION_ERROR_OUT_OF_MEMORY;
1278 return CONNECTION_ERROR_NONE;
1281 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1282 connection_cellular_auth_type_e* type, char** user_name, char** password)
1284 if (!(_connection_libnet_check_profile_validity(profile)) ||
1285 type == NULL || user_name == NULL || password == NULL) {
1286 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1287 return CONNECTION_ERROR_INVALID_PARAMETER;
1290 net_profile_info_t *profile_info = profile;
1292 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1293 return CONNECTION_ERROR_INVALID_PARAMETER;
1295 switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1296 case NET_PDP_AUTH_NONE:
1297 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1299 case NET_PDP_AUTH_PAP:
1300 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1302 case NET_PDP_AUTH_CHAP:
1303 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1306 return CONNECTION_ERROR_OPERATION_FAILED;
1309 *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1310 if (*user_name == NULL)
1311 return CONNECTION_ERROR_OUT_OF_MEMORY;
1313 *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1314 if (*password == NULL) {
1316 return CONNECTION_ERROR_OUT_OF_MEMORY;
1319 return CONNECTION_ERROR_NONE;
1322 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1324 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1325 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1326 return CONNECTION_ERROR_INVALID_PARAMETER;
1329 net_profile_info_t *profile_info = profile;
1331 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1332 return CONNECTION_ERROR_INVALID_PARAMETER;
1334 *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1335 if (*home_url == NULL)
1336 return CONNECTION_ERROR_OUT_OF_MEMORY;
1338 return CONNECTION_ERROR_NONE;
1341 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1343 if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1344 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1345 return CONNECTION_ERROR_INVALID_PARAMETER;
1348 net_profile_info_t *profile_info = profile;
1350 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1351 return CONNECTION_ERROR_INVALID_PARAMETER;
1353 if (profile_info->ProfileInfo.Pdp.Roaming)
1356 *is_roaming = false;
1358 return CONNECTION_ERROR_NONE;
1361 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
1363 if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
1364 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1365 return CONNECTION_ERROR_INVALID_PARAMETER;
1368 net_profile_info_t *profile_info = profile;
1370 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1371 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1372 return CONNECTION_ERROR_INVALID_PARAMETER;
1375 if (profile_info->ProfileInfo.Pdp.Hidden)
1380 return CONNECTION_ERROR_NONE;
1383 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
1385 if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
1386 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1387 return CONNECTION_ERROR_INVALID_PARAMETER;
1390 net_profile_info_t *profile_info = profile;
1392 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1393 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1394 return CONNECTION_ERROR_INVALID_PARAMETER;
1397 if (profile_info->ProfileInfo.Pdp.Editable)
1398 *is_editable = true;
1400 *is_editable = false;
1402 return CONNECTION_ERROR_NONE;
1405 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
1407 if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
1408 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1409 return CONNECTION_ERROR_INVALID_PARAMETER;
1412 net_profile_info_t *profile_info = profile;
1414 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1415 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1416 return CONNECTION_ERROR_INVALID_PARAMETER;
1419 if (profile_info->ProfileInfo.Pdp.DefaultConn)
1422 *is_default = false;
1424 return CONNECTION_ERROR_NONE;
1427 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
1428 connection_cellular_service_type_e service_type)
1430 if (!(_connection_libnet_check_profile_validity(profile))) {
1431 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1432 return CONNECTION_ERROR_INVALID_PARAMETER;
1435 net_profile_info_t *profile_info = profile;
1437 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1438 return CONNECTION_ERROR_INVALID_PARAMETER;
1440 switch (service_type) {
1441 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1442 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1444 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1445 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1447 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1448 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1450 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1451 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1453 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1454 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1456 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1457 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1459 case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1461 return CONNECTION_ERROR_INVALID_PARAMETER;
1464 return CONNECTION_ERROR_NONE;
1467 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1469 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1470 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1471 return CONNECTION_ERROR_INVALID_PARAMETER;
1474 net_profile_info_t *profile_info = profile;
1476 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1477 return CONNECTION_ERROR_INVALID_PARAMETER;
1479 g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1481 return CONNECTION_ERROR_NONE;
1484 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1485 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1487 if (!(_connection_libnet_check_profile_validity(profile)) ||
1488 user_name == NULL || password == NULL) {
1489 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1490 return CONNECTION_ERROR_INVALID_PARAMETER;
1493 net_profile_info_t *profile_info = profile;
1495 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1496 return CONNECTION_ERROR_INVALID_PARAMETER;
1499 case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1500 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1502 case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1503 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1505 case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1506 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1509 return CONNECTION_ERROR_INVALID_PARAMETER;
1512 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1513 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1515 return CONNECTION_ERROR_NONE;
1518 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1520 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1521 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1522 return CONNECTION_ERROR_INVALID_PARAMETER;
1525 net_profile_info_t *profile_info = profile;
1527 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1528 return CONNECTION_ERROR_INVALID_PARAMETER;
1530 g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1532 return CONNECTION_ERROR_NONE;