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"
27 static net_dev_info_t* __profile_get_net_info(net_profile_info_t *profile_info)
29 switch (profile_info->profile_type) {
30 case NET_DEVICE_CELLULAR:
31 return &profile_info->ProfileInfo.Pdp.net_info;
33 return &profile_info->ProfileInfo.Wlan.net_info;
34 case NET_DEVICE_ETHERNET:
35 return &profile_info->ProfileInfo.Ethernet.net_info;
36 case NET_DEVICE_BLUETOOTH:
37 return &profile_info->ProfileInfo.Bluetooth.net_info;
38 case NET_DEVICE_DEFAULT:
40 case NET_DEVICE_UNKNOWN:
47 static char* __profile_convert_ip_to_string(net_addr_t *ip_addr)
49 unsigned char *ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
51 char *ipstr = g_try_malloc0(16);
55 snprintf(ipstr, 16, "%d.%d.%d.%d", ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3]);
60 static void __profile_init_cellular_profile(net_profile_info_t *profile_info, const char *keyword)
62 profile_info->profile_type = NET_DEVICE_CELLULAR;
63 profile_info->ProfileState = NET_STATE_TYPE_IDLE;
64 profile_info->ProfileInfo.Pdp.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
65 profile_info->ProfileInfo.Pdp.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
66 g_strlcpy(profile_info->ProfileInfo.Pdp.Keyword, keyword, NET_PDP_APN_LEN_MAX);
69 static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
71 profile_info->profile_type = NET_DEVICE_WIFI;
72 profile_info->ProfileState = NET_STATE_TYPE_IDLE;
73 profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
74 profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
75 profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
76 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
77 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
80 static const char* __profile_get_ethernet_proxy(void)
84 proxy = getenv(HTTP_PROXY);
87 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
94 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
97 case NET_SERVICE_INTERNET:
98 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
100 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
101 case NET_SERVICE_PREPAID_INTERNET:
102 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
103 case NET_SERVICE_PREPAID_MMS:
104 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
105 case NET_SERVICE_TETHERING:
106 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
107 case NET_SERVICE_APPLICATION:
108 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
110 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
114 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
116 connection_profile_state_e cp_state;
119 case NET_STATE_TYPE_ONLINE:
120 case NET_STATE_TYPE_READY:
121 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
123 case NET_STATE_TYPE_IDLE:
124 case NET_STATE_TYPE_FAILURE:
125 case NET_STATE_TYPE_DISCONNECT:
126 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
128 case NET_STATE_TYPE_ASSOCIATION:
129 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
131 case NET_STATE_TYPE_CONFIGURATION:
132 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
141 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
144 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
145 return NET_SERVICE_INTERNET;
146 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
147 return NET_SERVICE_MMS;
148 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
149 return NET_SERVICE_PREPAID_INTERNET;
150 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
151 return NET_SERVICE_PREPAID_MMS;
152 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
153 return NET_SERVICE_TETHERING;
154 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
155 return NET_SERVICE_APPLICATION;
157 return NET_SERVICE_UNKNOWN;
161 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
163 net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
166 case CONNECTION_PROFILE_STATE_CONNECTED:
167 libnet_state = NET_STATE_TYPE_ONLINE;
169 case CONNECTION_PROFILE_STATE_DISCONNECTED:
170 libnet_state = NET_STATE_TYPE_IDLE;
172 case CONNECTION_PROFILE_STATE_ASSOCIATION:
173 libnet_state = NET_STATE_TYPE_ASSOCIATION;
175 case CONNECTION_PROFILE_STATE_CONFIGURATION:
176 libnet_state = NET_STATE_TYPE_CONFIGURATION;
184 /* Connection profile ********************************************************/
185 EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
187 if ((type != CONNECTION_PROFILE_TYPE_CELLULAR &&
188 type != CONNECTION_PROFILE_TYPE_WIFI) || profile == NULL) {
189 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
190 return CONNECTION_ERROR_INVALID_PARAMETER;
193 net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
194 if (profile_info == NULL)
195 return CONNECTION_ERROR_OUT_OF_MEMORY;
198 case CONNECTION_PROFILE_TYPE_CELLULAR:
199 if (keyword == NULL) {
200 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
201 g_free(profile_info);
202 return CONNECTION_ERROR_INVALID_PARAMETER;
204 __profile_init_cellular_profile(profile_info, keyword);
206 case CONNECTION_PROFILE_TYPE_WIFI:
207 __profile_init_wifi_profile(profile_info);
213 *profile = (connection_profile_h)profile_info;
214 _connection_libnet_add_to_profile_list(*profile);
216 return CONNECTION_ERROR_NONE;
219 EXPORT_API int connection_profile_destroy(connection_profile_h profile)
221 if (!(_connection_libnet_check_profile_validity(profile))) {
222 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
223 return CONNECTION_ERROR_INVALID_PARAMETER;
226 _connection_libnet_remove_from_profile_list(profile);
228 return CONNECTION_ERROR_NONE;
231 EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
233 if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
234 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
235 return CONNECTION_ERROR_INVALID_PARAMETER;
238 *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
239 if (*cloned_profile == NULL)
240 return CONNECTION_ERROR_OUT_OF_MEMORY;
242 memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
243 _connection_libnet_add_to_profile_list(*cloned_profile);
245 return CONNECTION_ERROR_NONE;
248 EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
250 if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
251 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
252 return CONNECTION_ERROR_INVALID_PARAMETER;
255 net_profile_info_t *profile_info = profile;
257 char *prof_id = strrchr(profile_info->ProfileName, '/');
259 return CONNECTION_ERROR_INVALID_PARAMETER;
262 *profile_id = g_strdup(prof_id);
264 if (*profile_id == NULL)
265 return CONNECTION_ERROR_OUT_OF_MEMORY;
267 return CONNECTION_ERROR_NONE;
270 EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
272 if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
273 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
274 return CONNECTION_ERROR_INVALID_PARAMETER;
277 net_profile_info_t *profile_info = profile;
279 switch (profile_info->profile_type) {
280 case NET_DEVICE_CELLULAR:
281 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
283 case NET_DEVICE_WIFI:
284 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
286 case NET_DEVICE_ETHERNET:
287 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName);
289 case NET_DEVICE_BLUETOOTH: {
290 char *bt_name = strrchr(profile_info->ProfileName, '/');
292 return CONNECTION_ERROR_INVALID_PARAMETER;
295 *profile_name = g_strdup(bt_name);
298 return CONNECTION_ERROR_INVALID_PARAMETER;
301 if (*profile_name == NULL)
302 return CONNECTION_ERROR_OUT_OF_MEMORY;
304 return CONNECTION_ERROR_NONE;
307 EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e* type)
309 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
310 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
311 return CONNECTION_ERROR_INVALID_PARAMETER;
314 net_profile_info_t *profile_info = profile;
316 switch (profile_info->profile_type) {
317 case NET_DEVICE_CELLULAR:
318 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
320 case NET_DEVICE_WIFI:
321 *type = CONNECTION_PROFILE_TYPE_WIFI;
323 case NET_DEVICE_ETHERNET:
324 *type = CONNECTION_PROFILE_TYPE_ETHERNET;
326 case NET_DEVICE_BLUETOOTH:
327 *type = CONNECTION_PROFILE_TYPE_BT;
330 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type\n");
331 return CONNECTION_ERROR_OPERATION_FAILED;
334 return CONNECTION_ERROR_NONE;
337 EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
339 if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
340 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
341 return CONNECTION_ERROR_INVALID_PARAMETER;
344 net_profile_info_t *profile_info = profile;
345 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
346 if (net_info == NULL)
347 return CONNECTION_ERROR_INVALID_PARAMETER;
349 *interface_name = g_strdup(net_info->DevName);
350 if (*interface_name == NULL)
351 return CONNECTION_ERROR_OUT_OF_MEMORY;
353 return CONNECTION_ERROR_NONE;
356 EXPORT_API int connection_profile_refresh(connection_profile_h profile)
358 if (!(_connection_libnet_check_profile_validity(profile))) {
359 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
360 return CONNECTION_ERROR_INVALID_PARAMETER;
363 net_profile_info_t profile_info_local;
364 net_profile_info_t *profile_info = profile;
366 if (net_get_profile_info(profile_info->ProfileName, &profile_info_local) != NET_ERR_NONE) {
367 CONNECTION_LOG(CONNECTION_ERROR, "Error!!! net_get_profile_info() failed\n");
368 return CONNECTION_ERROR_OPERATION_FAILED;
371 memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
373 return CONNECTION_ERROR_NONE;
376 EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
378 if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
379 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
380 return CONNECTION_ERROR_INVALID_PARAMETER;
383 net_profile_info_t *profile_info = profile;
384 *state = _profile_convert_to_cp_state(profile_info->ProfileState);
386 return CONNECTION_ERROR_OPERATION_FAILED;
388 return CONNECTION_ERROR_NONE;
391 EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
392 connection_address_family_e address_family, connection_ip_config_type_e* type)
394 if (!(_connection_libnet_check_profile_validity(profile)) ||
395 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
396 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
398 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
399 return CONNECTION_ERROR_INVALID_PARAMETER;
402 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
403 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
405 net_profile_info_t *profile_info = profile;
406 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
407 if (net_info == NULL)
408 return CONNECTION_ERROR_OPERATION_FAILED;
410 switch (net_info->IpConfigType) {
411 case NET_IP_CONFIG_TYPE_STATIC:
412 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
414 case NET_IP_CONFIG_TYPE_DYNAMIC:
415 *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
417 case NET_IP_CONFIG_TYPE_AUTO_IP:
418 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
420 case NET_IP_CONFIG_TYPE_FIXED:
421 *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
423 case NET_IP_CONFIG_TYPE_OFF:
424 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
427 return CONNECTION_ERROR_OPERATION_FAILED;
430 return CONNECTION_ERROR_NONE;
433 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
434 connection_address_family_e address_family, char** ip_address)
436 if (!(_connection_libnet_check_profile_validity(profile)) ||
437 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
438 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
439 ip_address == NULL) {
440 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
441 return CONNECTION_ERROR_INVALID_PARAMETER;
444 net_profile_info_t *profile_info = profile;
445 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
446 if (net_info == NULL)
447 return CONNECTION_ERROR_OPERATION_FAILED;
449 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
450 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
452 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr);
453 if (*ip_address == NULL)
454 return CONNECTION_ERROR_OUT_OF_MEMORY;
456 return CONNECTION_ERROR_NONE;
459 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
460 connection_address_family_e address_family, char** subnet_mask)
462 if (!(_connection_libnet_check_profile_validity(profile)) ||
463 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
464 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
465 subnet_mask == NULL) {
466 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
467 return CONNECTION_ERROR_INVALID_PARAMETER;
470 net_profile_info_t *profile_info = profile;
471 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
472 if (net_info == NULL)
473 return CONNECTION_ERROR_OPERATION_FAILED;
475 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
476 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
478 *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask);
479 if (*subnet_mask == NULL)
480 return CONNECTION_ERROR_OUT_OF_MEMORY;
482 return CONNECTION_ERROR_NONE;
485 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
486 connection_address_family_e address_family, char** gateway_address)
488 if (!(_connection_libnet_check_profile_validity(profile)) ||
489 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
490 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
491 gateway_address == NULL) {
492 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
493 return CONNECTION_ERROR_INVALID_PARAMETER;
496 net_profile_info_t *profile_info = profile;
497 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
498 if (net_info == NULL)
499 return CONNECTION_ERROR_OPERATION_FAILED;
501 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
502 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
504 *gateway_address = __profile_convert_ip_to_string(&net_info->GatewayAddr);
505 if (*gateway_address == NULL)
506 return CONNECTION_ERROR_OUT_OF_MEMORY;
508 return CONNECTION_ERROR_NONE;
511 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
512 connection_address_family_e address_family, char** dns_address)
514 if (!(_connection_libnet_check_profile_validity(profile)) ||
515 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
516 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
517 dns_address == NULL ||
519 order > NET_DNS_ADDR_MAX) {
520 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
521 return CONNECTION_ERROR_INVALID_PARAMETER;
524 net_profile_info_t *profile_info = profile;
525 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
526 if (net_info == NULL)
527 return CONNECTION_ERROR_OPERATION_FAILED;
529 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
530 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
532 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1]);
533 if (*dns_address == NULL)
534 return CONNECTION_ERROR_OUT_OF_MEMORY;
536 return CONNECTION_ERROR_NONE;
539 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e* type)
541 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
542 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
543 return CONNECTION_ERROR_INVALID_PARAMETER;
547 net_profile_info_t *profile_info = profile;
548 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
549 if (net_info == NULL)
550 return CONNECTION_ERROR_OPERATION_FAILED;
552 if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
553 proxy = __profile_get_ethernet_proxy();
555 *type = CONNECTION_PROXY_TYPE_DIRECT;
557 *type = CONNECTION_PROXY_TYPE_MANUAL;
559 return CONNECTION_ERROR_NONE;
562 switch (net_info->ProxyMethod) {
563 case NET_PROXY_TYPE_DIRECT:
564 *type = CONNECTION_PROXY_TYPE_DIRECT;
566 case NET_PROXY_TYPE_AUTO:
567 *type = CONNECTION_PROXY_TYPE_AUTO;
569 case NET_PROXY_TYPE_MANUAL:
570 *type = CONNECTION_PROXY_TYPE_MANUAL;
572 case NET_PROXY_TYPE_UNKNOWN:
574 return CONNECTION_ERROR_OPERATION_FAILED;
577 return CONNECTION_ERROR_NONE;
580 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
581 connection_address_family_e address_family, char** proxy_address)
583 if (!(_connection_libnet_check_profile_validity(profile)) ||
584 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
585 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
586 proxy_address == NULL) {
587 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
588 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_IPV6)
598 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
600 if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
601 proxy = __profile_get_ethernet_proxy();
603 return CONNECTION_ERROR_OPERATION_FAILED;
605 *proxy_address = g_strdup(proxy);
607 *proxy_address = g_strdup(net_info->ProxyAddr);
609 if (*proxy_address == NULL)
610 return CONNECTION_ERROR_OUT_OF_MEMORY;
612 return CONNECTION_ERROR_NONE;
615 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
616 connection_address_family_e address_family, connection_ip_config_type_e type)
618 if (!(_connection_libnet_check_profile_validity(profile)) ||
619 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
620 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
621 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
622 return CONNECTION_ERROR_INVALID_PARAMETER;
625 net_profile_info_t *profile_info = profile;
626 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
627 if (net_info == NULL)
628 return CONNECTION_ERROR_OPERATION_FAILED;
630 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
631 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
634 case CONNECTION_IP_CONFIG_TYPE_STATIC:
635 net_info->IpConfigType = NET_IP_CONFIG_TYPE_STATIC;
636 net_info->IpAddr.Data.Ipv4.s_addr = 0;
637 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
638 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
640 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
641 net_info->IpConfigType = NET_IP_CONFIG_TYPE_DYNAMIC;
643 case CONNECTION_IP_CONFIG_TYPE_AUTO:
644 net_info->IpConfigType = NET_IP_CONFIG_TYPE_AUTO_IP;
646 case CONNECTION_IP_CONFIG_TYPE_FIXED:
647 net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
649 case CONNECTION_IP_CONFIG_TYPE_NONE:
650 net_info->IpConfigType = NET_IP_CONFIG_TYPE_OFF;
653 return CONNECTION_ERROR_INVALID_PARAMETER;
656 return CONNECTION_ERROR_NONE;
659 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
660 connection_address_family_e address_family, const char* ip_address)
662 if (!(_connection_libnet_check_profile_validity(profile)) ||
663 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
664 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
665 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
666 return CONNECTION_ERROR_INVALID_PARAMETER;
669 net_profile_info_t *profile_info = profile;
670 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
671 if (net_info == NULL)
672 return CONNECTION_ERROR_OPERATION_FAILED;
674 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
675 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
677 if (ip_address == NULL)
678 net_info->IpAddr.Data.Ipv4.s_addr = 0;
679 else if (inet_aton(ip_address, &(net_info->IpAddr.Data.Ipv4)) == 0)
680 return CONNECTION_ERROR_INVALID_PARAMETER;
682 return CONNECTION_ERROR_NONE;
685 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
686 connection_address_family_e address_family, const char* subnet_mask)
688 if (!(_connection_libnet_check_profile_validity(profile)) ||
689 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
690 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
691 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
692 return CONNECTION_ERROR_INVALID_PARAMETER;
695 net_profile_info_t *profile_info = profile;
696 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
697 if (net_info == NULL)
698 return CONNECTION_ERROR_OPERATION_FAILED;
700 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
701 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
703 if (subnet_mask == NULL)
704 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
705 else if (inet_aton(subnet_mask, &(net_info->SubnetMask.Data.Ipv4)) == 0)
706 return CONNECTION_ERROR_INVALID_PARAMETER;
708 return CONNECTION_ERROR_NONE;
711 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
712 connection_address_family_e address_family, const char* gateway_address)
714 if (!(_connection_libnet_check_profile_validity(profile)) ||
715 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
716 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
717 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
718 return CONNECTION_ERROR_INVALID_PARAMETER;
721 net_profile_info_t *profile_info = profile;
722 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
723 if (net_info == NULL)
724 return CONNECTION_ERROR_OPERATION_FAILED;
726 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
727 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
729 if (gateway_address == NULL)
730 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
731 else if (inet_aton(gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) == 0)
732 return CONNECTION_ERROR_INVALID_PARAMETER;
734 return CONNECTION_ERROR_NONE;
737 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
738 connection_address_family_e address_family, const char* dns_address)
740 if (!(_connection_libnet_check_profile_validity(profile)) ||
741 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
742 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
744 order > NET_DNS_ADDR_MAX) {
745 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
746 return CONNECTION_ERROR_INVALID_PARAMETER;
749 net_profile_info_t *profile_info = profile;
750 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
751 if (net_info == NULL)
752 return CONNECTION_ERROR_OPERATION_FAILED;
754 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
755 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
757 if (dns_address == NULL)
758 net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
759 else if (inet_aton(dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) == 0)
760 return CONNECTION_ERROR_INVALID_PARAMETER;
762 return CONNECTION_ERROR_NONE;
765 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
767 if (!(_connection_libnet_check_profile_validity(profile))) {
768 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
769 return CONNECTION_ERROR_INVALID_PARAMETER;
772 net_profile_info_t *profile_info = profile;
773 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
774 if (net_info == NULL)
775 return CONNECTION_ERROR_OPERATION_FAILED;
778 case CONNECTION_PROXY_TYPE_DIRECT:
779 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
781 case CONNECTION_PROXY_TYPE_AUTO:
782 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
784 case CONNECTION_PROXY_TYPE_MANUAL:
785 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
788 return CONNECTION_ERROR_INVALID_PARAMETER;
791 return CONNECTION_ERROR_NONE;
794 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
795 connection_address_family_e address_family, const char* proxy_address)
797 if (!(_connection_libnet_check_profile_validity(profile)) ||
798 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
799 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
800 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
801 return CONNECTION_ERROR_INVALID_PARAMETER;
804 net_profile_info_t *profile_info = profile;
805 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
806 if (net_info == NULL)
807 return CONNECTION_ERROR_OPERATION_FAILED;
809 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
810 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
812 if (proxy_address == NULL)
813 net_info->ProxyAddr[0] = '\0';
815 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
817 return CONNECTION_ERROR_NONE;
820 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
821 connection_profile_state_changed_cb callback, void* user_data)
823 if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
824 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
825 return CONNECTION_ERROR_INVALID_PARAMETER;
828 if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
829 return CONNECTION_ERROR_NONE;
831 return CONNECTION_ERROR_OPERATION_FAILED;
834 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
836 if (!(_connection_libnet_check_profile_cb_validity(profile))) {
837 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
838 return CONNECTION_ERROR_INVALID_PARAMETER;
841 _connection_libnet_remove_from_profile_cb_list(profile);
843 return CONNECTION_ERROR_NONE;
847 /* Wi-Fi profile *************************************************************/
848 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
850 if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
851 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
852 return CONNECTION_ERROR_INVALID_PARAMETER;
855 net_profile_info_t *profile_info = profile;
857 if (profile_info->profile_type != NET_DEVICE_WIFI)
858 return CONNECTION_ERROR_INVALID_PARAMETER;
860 *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
862 return CONNECTION_ERROR_OUT_OF_MEMORY;
864 return CONNECTION_ERROR_NONE;
867 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
869 if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
870 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
871 return CONNECTION_ERROR_INVALID_PARAMETER;
874 net_profile_info_t *profile_info = profile;
876 if (profile_info->profile_type != NET_DEVICE_WIFI)
877 return CONNECTION_ERROR_INVALID_PARAMETER;
879 *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
881 return CONNECTION_ERROR_OUT_OF_MEMORY;
883 return CONNECTION_ERROR_NONE;
886 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
888 if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
889 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
890 return CONNECTION_ERROR_INVALID_PARAMETER;
893 net_profile_info_t *profile_info = profile;
895 if (profile_info->profile_type != NET_DEVICE_WIFI)
896 return CONNECTION_ERROR_INVALID_PARAMETER;
898 *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
900 return CONNECTION_ERROR_NONE;
903 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
905 if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
906 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
907 return CONNECTION_ERROR_INVALID_PARAMETER;
910 net_profile_info_t *profile_info = profile;
912 if (profile_info->profile_type != NET_DEVICE_WIFI)
913 return CONNECTION_ERROR_INVALID_PARAMETER;
915 *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
917 return CONNECTION_ERROR_NONE;
920 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
922 if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
923 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
924 return CONNECTION_ERROR_INVALID_PARAMETER;
927 net_profile_info_t *profile_info = profile;
929 if (profile_info->profile_type != NET_DEVICE_WIFI)
930 return CONNECTION_ERROR_INVALID_PARAMETER;
932 *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate;
934 return CONNECTION_ERROR_NONE;
937 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e* type)
939 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
940 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
941 return CONNECTION_ERROR_INVALID_PARAMETER;
944 net_profile_info_t *profile_info = profile;
946 if (profile_info->profile_type != NET_DEVICE_WIFI)
947 return CONNECTION_ERROR_INVALID_PARAMETER;
949 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
950 case WLAN_SEC_MODE_NONE:
951 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
953 case WLAN_SEC_MODE_WEP:
954 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
956 case WLAN_SEC_MODE_IEEE8021X:
957 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
959 case WLAN_SEC_MODE_WPA_PSK:
960 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
962 case WLAN_SEC_MODE_WPA2_PSK:
963 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
966 return CONNECTION_ERROR_OPERATION_FAILED;
969 return CONNECTION_ERROR_NONE;
972 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e* type)
974 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
975 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
976 return CONNECTION_ERROR_INVALID_PARAMETER;
979 net_profile_info_t *profile_info = profile;
981 if (profile_info->profile_type != NET_DEVICE_WIFI)
982 return CONNECTION_ERROR_INVALID_PARAMETER;
984 switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
985 case WLAN_ENC_MODE_NONE:
986 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
988 case WLAN_ENC_MODE_WEP:
989 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
991 case WLAN_ENC_MODE_TKIP:
992 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
994 case WLAN_ENC_MODE_AES:
995 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
997 case WLAN_ENC_MODE_TKIP_AES_MIXED:
998 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1001 return CONNECTION_ERROR_OPERATION_FAILED;
1004 return CONNECTION_ERROR_NONE;
1007 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1009 if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1010 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1011 return CONNECTION_ERROR_INVALID_PARAMETER;
1014 net_profile_info_t *profile_info = profile;
1016 if (profile_info->profile_type != NET_DEVICE_WIFI)
1017 return CONNECTION_ERROR_INVALID_PARAMETER;
1019 if (profile_info->Favourite) {
1021 return CONNECTION_ERROR_NONE;
1024 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1025 case WLAN_SEC_MODE_NONE:
1028 case WLAN_SEC_MODE_WEP:
1029 case WLAN_SEC_MODE_IEEE8021X:
1030 case WLAN_SEC_MODE_WPA_PSK:
1031 case WLAN_SEC_MODE_WPA2_PSK:
1035 return CONNECTION_ERROR_OPERATION_FAILED;
1038 return CONNECTION_ERROR_NONE;
1041 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1043 if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1044 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1045 return CONNECTION_ERROR_INVALID_PARAMETER;
1048 net_profile_info_t *profile_info = profile;
1050 if (profile_info->profile_type != NET_DEVICE_WIFI)
1051 return CONNECTION_ERROR_INVALID_PARAMETER;
1053 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1054 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1056 return CONNECTION_ERROR_NONE;
1059 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1061 if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1062 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1063 return CONNECTION_ERROR_INVALID_PARAMETER;
1066 net_profile_info_t *profile_info = profile;
1068 if (profile_info->profile_type != NET_DEVICE_WIFI)
1069 return CONNECTION_ERROR_INVALID_PARAMETER;
1071 if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1076 return CONNECTION_ERROR_NONE;
1080 /* Cellular profile **********************************************************/
1081 EXPORT_API int connection_profile_get_cellular_network_type(connection_profile_h profile, connection_cellular_network_type_e* type)
1083 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1084 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1085 return CONNECTION_ERROR_INVALID_PARAMETER;
1089 net_profile_info_t *profile_info = profile;
1091 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1092 return CONNECTION_ERROR_INVALID_PARAMETER;
1094 if (vconf_get_int(VCONFKEY_TELEPHONY_SVC_ACT, &network_type)) {
1095 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed\n");
1096 return CONNECTION_ERROR_OPERATION_FAILED;
1099 CONNECTION_LOG(CONNECTION_INFO, "Cellular network type = %d\n", network_type);
1101 switch (network_type) {
1102 case VCONFKEY_TELEPHONY_SVC_ACT_NONE:
1103 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UNKNOWN;
1105 case VCONFKEY_TELEPHONY_SVC_ACT_GPRS:
1106 *type = CONNECTION_CELLULAR_NETWORK_TYPE_GPRS;
1108 case VCONFKEY_TELEPHONY_SVC_ACT_EGPRS:
1109 *type = CONNECTION_CELLULAR_NETWORK_TYPE_EDGE;
1111 case VCONFKEY_TELEPHONY_SVC_ACT_UMTS:
1112 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UMTS;
1115 return CONNECTION_ERROR_OPERATION_FAILED;
1118 return CONNECTION_ERROR_NONE;
1121 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1122 connection_cellular_service_type_e* type)
1124 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1125 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1126 return CONNECTION_ERROR_INVALID_PARAMETER;
1129 net_profile_info_t *profile_info = profile;
1131 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1132 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type Passed\n");
1133 return CONNECTION_ERROR_INVALID_PARAMETER;
1136 *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1138 if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1139 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed\n");
1140 return CONNECTION_ERROR_OPERATION_FAILED;
1143 return CONNECTION_ERROR_NONE;
1146 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1148 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1149 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1150 return CONNECTION_ERROR_INVALID_PARAMETER;
1153 net_profile_info_t *profile_info = profile;
1155 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1156 return CONNECTION_ERROR_INVALID_PARAMETER;
1158 *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1160 return CONNECTION_ERROR_OUT_OF_MEMORY;
1162 return CONNECTION_ERROR_NONE;
1165 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1166 connection_cellular_auth_type_e* type, char** user_name, char** password)
1168 if (!(_connection_libnet_check_profile_validity(profile)) ||
1169 type == NULL || user_name == NULL || password == NULL) {
1170 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1171 return CONNECTION_ERROR_INVALID_PARAMETER;
1174 net_profile_info_t *profile_info = profile;
1176 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1177 return CONNECTION_ERROR_INVALID_PARAMETER;
1179 switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1180 case NET_PDP_AUTH_NONE:
1181 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1183 case NET_PDP_AUTH_PAP:
1184 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1186 case NET_PDP_AUTH_CHAP:
1187 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1190 return CONNECTION_ERROR_OPERATION_FAILED;
1193 *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1194 if (*user_name == NULL)
1195 return CONNECTION_ERROR_OUT_OF_MEMORY;
1197 *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1198 if (*password == NULL) {
1200 return CONNECTION_ERROR_OUT_OF_MEMORY;
1203 return CONNECTION_ERROR_NONE;
1206 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1208 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1209 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1210 return CONNECTION_ERROR_INVALID_PARAMETER;
1213 net_profile_info_t *profile_info = profile;
1215 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1216 return CONNECTION_ERROR_INVALID_PARAMETER;
1218 *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1219 if (*home_url == NULL)
1220 return CONNECTION_ERROR_OUT_OF_MEMORY;
1222 return CONNECTION_ERROR_NONE;
1225 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1227 if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1228 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1229 return CONNECTION_ERROR_INVALID_PARAMETER;
1232 net_profile_info_t *profile_info = profile;
1234 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1235 return CONNECTION_ERROR_INVALID_PARAMETER;
1237 if (profile_info->ProfileInfo.Pdp.Roaming)
1240 *is_roaming = false;
1242 return CONNECTION_ERROR_NONE;
1245 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
1246 connection_cellular_service_type_e service_type)
1248 if (!(_connection_libnet_check_profile_validity(profile))) {
1249 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1250 return CONNECTION_ERROR_INVALID_PARAMETER;
1253 net_profile_info_t *profile_info = profile;
1255 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1256 return CONNECTION_ERROR_INVALID_PARAMETER;
1258 switch (service_type) {
1259 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1260 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1262 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1263 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1265 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1266 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1268 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1269 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1271 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1272 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1274 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1275 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1277 case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1279 return CONNECTION_ERROR_INVALID_PARAMETER;
1282 return CONNECTION_ERROR_NONE;
1285 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1287 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1288 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1289 return CONNECTION_ERROR_INVALID_PARAMETER;
1292 net_profile_info_t *profile_info = profile;
1294 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1295 return CONNECTION_ERROR_INVALID_PARAMETER;
1297 g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1299 return CONNECTION_ERROR_NONE;
1302 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1303 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1305 if (!(_connection_libnet_check_profile_validity(profile)) ||
1306 user_name == NULL || password == NULL) {
1307 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1308 return CONNECTION_ERROR_INVALID_PARAMETER;
1311 net_profile_info_t *profile_info = profile;
1313 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1314 return CONNECTION_ERROR_INVALID_PARAMETER;
1317 case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1318 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1320 case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1321 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1323 case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1324 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1327 return CONNECTION_ERROR_INVALID_PARAMETER;
1330 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1331 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1333 return CONNECTION_ERROR_NONE;
1336 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1338 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1339 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1340 return CONNECTION_ERROR_INVALID_PARAMETER;
1343 net_profile_info_t *profile_info = profile;
1345 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1346 return CONNECTION_ERROR_INVALID_PARAMETER;
1348 g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1350 return CONNECTION_ERROR_NONE;