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 int default_subscriber_id = 0;
63 connection_profile_h profile = NULL;
65 profile_info->profile_type = NET_DEVICE_CELLULAR;
66 profile_info->ProfileState = NET_STATE_TYPE_IDLE;
67 profile_info->ProfileInfo.Pdp.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
68 profile_info->ProfileInfo.Pdp.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
69 g_strlcpy(profile_info->ProfileInfo.Pdp.Keyword, keyword, NET_PDP_APN_LEN_MAX);
71 if (vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE,
72 &default_subscriber_id) != 0)
73 CONNECTION_LOG(CONNECTION_ERROR,
74 "Failed to get VCONF_TELEPHONY_DEFAULT_DATA_SERVICE");
76 profile = (connection_profile_h)profile_info;
77 _connection_libnet_set_cellular_subscriber_id(profile, default_subscriber_id);
80 static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
82 profile_info->profile_type = NET_DEVICE_WIFI;
83 profile_info->ProfileState = NET_STATE_TYPE_IDLE;
84 profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
85 profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
86 profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
87 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
88 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
91 static const char* __profile_get_ethernet_proxy(void)
95 proxy = getenv(HTTP_PROXY);
98 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
105 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
108 case NET_SERVICE_INTERNET:
109 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
110 case NET_SERVICE_MMS:
111 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
112 case NET_SERVICE_PREPAID_INTERNET:
113 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
114 case NET_SERVICE_PREPAID_MMS:
115 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
116 case NET_SERVICE_TETHERING:
117 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
118 case NET_SERVICE_APPLICATION:
119 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
121 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
125 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
127 connection_profile_state_e cp_state;
130 case NET_STATE_TYPE_ONLINE:
131 case NET_STATE_TYPE_READY:
132 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
134 case NET_STATE_TYPE_IDLE:
135 case NET_STATE_TYPE_FAILURE:
136 case NET_STATE_TYPE_DISCONNECT:
137 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
139 case NET_STATE_TYPE_ASSOCIATION:
140 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
142 case NET_STATE_TYPE_CONFIGURATION:
143 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
152 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
155 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
156 return NET_SERVICE_INTERNET;
157 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
158 return NET_SERVICE_MMS;
159 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
160 return NET_SERVICE_PREPAID_INTERNET;
161 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
162 return NET_SERVICE_PREPAID_MMS;
163 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
164 return NET_SERVICE_TETHERING;
165 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
166 return NET_SERVICE_APPLICATION;
168 return NET_SERVICE_UNKNOWN;
172 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
174 net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
177 case CONNECTION_PROFILE_STATE_CONNECTED:
178 libnet_state = NET_STATE_TYPE_ONLINE;
180 case CONNECTION_PROFILE_STATE_DISCONNECTED:
181 libnet_state = NET_STATE_TYPE_IDLE;
183 case CONNECTION_PROFILE_STATE_ASSOCIATION:
184 libnet_state = NET_STATE_TYPE_ASSOCIATION;
186 case CONNECTION_PROFILE_STATE_CONFIGURATION:
187 libnet_state = NET_STATE_TYPE_CONFIGURATION;
195 /* Connection profile ********************************************************/
196 EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
198 if ((type != CONNECTION_PROFILE_TYPE_CELLULAR &&
199 type != CONNECTION_PROFILE_TYPE_WIFI) || profile == NULL) {
200 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
201 return CONNECTION_ERROR_INVALID_PARAMETER;
204 net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
205 if (profile_info == NULL)
206 return CONNECTION_ERROR_OUT_OF_MEMORY;
209 case CONNECTION_PROFILE_TYPE_CELLULAR:
210 if (keyword == NULL) {
211 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
212 g_free(profile_info);
213 return CONNECTION_ERROR_INVALID_PARAMETER;
215 __profile_init_cellular_profile(profile_info, keyword);
217 case CONNECTION_PROFILE_TYPE_WIFI:
218 __profile_init_wifi_profile(profile_info);
224 *profile = (connection_profile_h)profile_info;
225 _connection_libnet_add_to_profile_list(*profile);
227 return CONNECTION_ERROR_NONE;
230 EXPORT_API int connection_profile_destroy(connection_profile_h profile)
232 if (!(_connection_libnet_check_profile_validity(profile))) {
233 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
234 return CONNECTION_ERROR_INVALID_PARAMETER;
237 _connection_libnet_remove_from_profile_list(profile);
239 return CONNECTION_ERROR_NONE;
242 EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
244 if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
245 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
246 return CONNECTION_ERROR_INVALID_PARAMETER;
249 *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
250 if (*cloned_profile == NULL)
251 return CONNECTION_ERROR_OUT_OF_MEMORY;
253 memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
254 _connection_libnet_add_to_profile_list(*cloned_profile);
256 return CONNECTION_ERROR_NONE;
259 EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
261 if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
262 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
263 return CONNECTION_ERROR_INVALID_PARAMETER;
266 net_profile_info_t *profile_info = profile;
268 char *prof_id = strrchr(profile_info->ProfileName, '/');
270 return CONNECTION_ERROR_INVALID_PARAMETER;
273 *profile_id = g_strdup(prof_id);
275 if (*profile_id == NULL)
276 return CONNECTION_ERROR_OUT_OF_MEMORY;
278 return CONNECTION_ERROR_NONE;
281 EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
283 if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
284 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
285 return CONNECTION_ERROR_INVALID_PARAMETER;
288 net_profile_info_t *profile_info = profile;
290 switch (profile_info->profile_type) {
291 case NET_DEVICE_CELLULAR:
292 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
294 case NET_DEVICE_WIFI:
295 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
297 case NET_DEVICE_ETHERNET:
298 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName);
300 case NET_DEVICE_BLUETOOTH: {
301 char *bt_name = strrchr(profile_info->ProfileName, '/');
303 return CONNECTION_ERROR_INVALID_PARAMETER;
306 *profile_name = g_strdup(bt_name);
309 return CONNECTION_ERROR_INVALID_PARAMETER;
312 if (*profile_name == NULL)
313 return CONNECTION_ERROR_OUT_OF_MEMORY;
315 return CONNECTION_ERROR_NONE;
318 EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e* type)
320 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
321 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
322 return CONNECTION_ERROR_INVALID_PARAMETER;
325 net_profile_info_t *profile_info = profile;
327 switch (profile_info->profile_type) {
328 case NET_DEVICE_CELLULAR:
329 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
331 case NET_DEVICE_WIFI:
332 *type = CONNECTION_PROFILE_TYPE_WIFI;
334 case NET_DEVICE_ETHERNET:
335 *type = CONNECTION_PROFILE_TYPE_ETHERNET;
337 case NET_DEVICE_BLUETOOTH:
338 *type = CONNECTION_PROFILE_TYPE_BT;
341 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type\n");
342 return CONNECTION_ERROR_OPERATION_FAILED;
345 return CONNECTION_ERROR_NONE;
348 EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
350 if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
351 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
352 return CONNECTION_ERROR_INVALID_PARAMETER;
355 net_profile_info_t *profile_info = profile;
356 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
357 if (net_info == NULL)
358 return CONNECTION_ERROR_INVALID_PARAMETER;
360 *interface_name = g_strdup(net_info->DevName);
361 if (*interface_name == NULL)
362 return CONNECTION_ERROR_OUT_OF_MEMORY;
364 return CONNECTION_ERROR_NONE;
367 EXPORT_API int connection_profile_refresh(connection_profile_h profile)
370 if (!(_connection_libnet_check_profile_validity(profile))) {
371 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
372 return CONNECTION_ERROR_INVALID_PARAMETER;
375 net_profile_info_t profile_info_local;
376 net_profile_info_t *profile_info = profile;
378 rv = net_get_profile_info(profile_info->ProfileName, &profile_info_local);
379 if (rv == NET_ERR_ACCESS_DENIED) {
380 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
381 return CONNECTION_ERROR_PERMISSION_DENIED;
382 } else if (rv != NET_ERR_NONE) {
383 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile information");
384 return CONNECTION_ERROR_OPERATION_FAILED;
387 memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
389 return CONNECTION_ERROR_NONE;
392 EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
394 if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
395 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
396 return CONNECTION_ERROR_INVALID_PARAMETER;
399 net_profile_info_t *profile_info = profile;
400 *state = _profile_convert_to_cp_state(profile_info->ProfileState);
402 return CONNECTION_ERROR_OPERATION_FAILED;
404 return CONNECTION_ERROR_NONE;
407 EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
408 connection_address_family_e address_family, connection_ip_config_type_e* type)
410 if (!(_connection_libnet_check_profile_validity(profile)) ||
411 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
412 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
414 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
415 return CONNECTION_ERROR_INVALID_PARAMETER;
418 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
419 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
421 net_profile_info_t *profile_info = profile;
422 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
423 if (net_info == NULL)
424 return CONNECTION_ERROR_OPERATION_FAILED;
426 switch (net_info->IpConfigType) {
427 case NET_IP_CONFIG_TYPE_STATIC:
428 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
430 case NET_IP_CONFIG_TYPE_DYNAMIC:
431 *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
433 case NET_IP_CONFIG_TYPE_AUTO_IP:
434 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
436 case NET_IP_CONFIG_TYPE_FIXED:
437 *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
439 case NET_IP_CONFIG_TYPE_OFF:
440 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
443 return CONNECTION_ERROR_OPERATION_FAILED;
446 return CONNECTION_ERROR_NONE;
449 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
450 connection_address_family_e address_family, char** ip_address)
452 if (!(_connection_libnet_check_profile_validity(profile)) ||
453 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
454 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
455 ip_address == NULL) {
456 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
457 return CONNECTION_ERROR_INVALID_PARAMETER;
460 net_profile_info_t *profile_info = profile;
461 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
462 if (net_info == NULL)
463 return CONNECTION_ERROR_OPERATION_FAILED;
465 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
466 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
468 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr);
469 if (*ip_address == NULL)
470 return CONNECTION_ERROR_OUT_OF_MEMORY;
472 return CONNECTION_ERROR_NONE;
475 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
476 connection_address_family_e address_family, char** subnet_mask)
478 if (!(_connection_libnet_check_profile_validity(profile)) ||
479 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
480 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
481 subnet_mask == NULL) {
482 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
483 return CONNECTION_ERROR_INVALID_PARAMETER;
486 net_profile_info_t *profile_info = profile;
487 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
488 if (net_info == NULL)
489 return CONNECTION_ERROR_OPERATION_FAILED;
491 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
492 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
494 *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask);
495 if (*subnet_mask == NULL)
496 return CONNECTION_ERROR_OUT_OF_MEMORY;
498 return CONNECTION_ERROR_NONE;
501 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
502 connection_address_family_e address_family, char** gateway_address)
504 if (!(_connection_libnet_check_profile_validity(profile)) ||
505 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
506 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
507 gateway_address == NULL) {
508 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
509 return CONNECTION_ERROR_INVALID_PARAMETER;
512 net_profile_info_t *profile_info = profile;
513 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
514 if (net_info == NULL)
515 return CONNECTION_ERROR_OPERATION_FAILED;
517 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
518 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
520 *gateway_address = __profile_convert_ip_to_string(&net_info->GatewayAddr);
521 if (*gateway_address == NULL)
522 return CONNECTION_ERROR_OUT_OF_MEMORY;
524 return CONNECTION_ERROR_NONE;
527 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
528 connection_address_family_e address_family, char** dns_address)
530 if (!(_connection_libnet_check_profile_validity(profile)) ||
531 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
532 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
533 dns_address == NULL ||
535 order > NET_DNS_ADDR_MAX) {
536 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
537 return CONNECTION_ERROR_INVALID_PARAMETER;
540 net_profile_info_t *profile_info = profile;
541 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
542 if (net_info == NULL)
543 return CONNECTION_ERROR_OPERATION_FAILED;
545 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
546 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
548 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1]);
549 if (*dns_address == NULL)
550 return CONNECTION_ERROR_OUT_OF_MEMORY;
552 return CONNECTION_ERROR_NONE;
555 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e* type)
557 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
558 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
559 return CONNECTION_ERROR_INVALID_PARAMETER;
563 net_profile_info_t *profile_info = profile;
564 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
565 if (net_info == NULL)
566 return CONNECTION_ERROR_OPERATION_FAILED;
568 if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
569 proxy = __profile_get_ethernet_proxy();
571 *type = CONNECTION_PROXY_TYPE_DIRECT;
573 *type = CONNECTION_PROXY_TYPE_MANUAL;
575 return CONNECTION_ERROR_NONE;
578 switch (net_info->ProxyMethod) {
579 case NET_PROXY_TYPE_DIRECT:
580 *type = CONNECTION_PROXY_TYPE_DIRECT;
582 case NET_PROXY_TYPE_AUTO:
583 *type = CONNECTION_PROXY_TYPE_AUTO;
585 case NET_PROXY_TYPE_MANUAL:
586 *type = CONNECTION_PROXY_TYPE_MANUAL;
588 case NET_PROXY_TYPE_UNKNOWN:
590 return CONNECTION_ERROR_OPERATION_FAILED;
593 return CONNECTION_ERROR_NONE;
596 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
597 connection_address_family_e address_family, char** proxy_address)
599 if (!(_connection_libnet_check_profile_validity(profile)) ||
600 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
601 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
602 proxy_address == NULL) {
603 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
604 return CONNECTION_ERROR_INVALID_PARAMETER;
608 net_profile_info_t *profile_info = profile;
609 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
610 if (net_info == NULL)
611 return CONNECTION_ERROR_OPERATION_FAILED;
613 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
614 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
616 if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
617 proxy = __profile_get_ethernet_proxy();
619 return CONNECTION_ERROR_OPERATION_FAILED;
621 *proxy_address = g_strdup(proxy);
623 *proxy_address = g_strdup(net_info->ProxyAddr);
625 if (*proxy_address == NULL)
626 return CONNECTION_ERROR_OUT_OF_MEMORY;
628 return CONNECTION_ERROR_NONE;
631 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
632 connection_address_family_e address_family, connection_ip_config_type_e type)
634 if (!(_connection_libnet_check_profile_validity(profile)) ||
635 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
636 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
637 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
638 return CONNECTION_ERROR_INVALID_PARAMETER;
641 net_profile_info_t *profile_info = profile;
642 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
643 if (net_info == NULL)
644 return CONNECTION_ERROR_OPERATION_FAILED;
646 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
647 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
650 case CONNECTION_IP_CONFIG_TYPE_STATIC:
651 net_info->IpConfigType = NET_IP_CONFIG_TYPE_STATIC;
652 net_info->IpAddr.Data.Ipv4.s_addr = 0;
653 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
654 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
656 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
657 net_info->IpConfigType = NET_IP_CONFIG_TYPE_DYNAMIC;
659 case CONNECTION_IP_CONFIG_TYPE_AUTO:
660 net_info->IpConfigType = NET_IP_CONFIG_TYPE_AUTO_IP;
662 case CONNECTION_IP_CONFIG_TYPE_FIXED:
663 net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
665 case CONNECTION_IP_CONFIG_TYPE_NONE:
666 net_info->IpConfigType = NET_IP_CONFIG_TYPE_OFF;
669 return CONNECTION_ERROR_INVALID_PARAMETER;
672 return CONNECTION_ERROR_NONE;
675 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
676 connection_address_family_e address_family, const char* ip_address)
678 if (!(_connection_libnet_check_profile_validity(profile)) ||
679 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
680 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
681 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
682 return CONNECTION_ERROR_INVALID_PARAMETER;
685 net_profile_info_t *profile_info = profile;
686 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
687 if (net_info == NULL)
688 return CONNECTION_ERROR_OPERATION_FAILED;
690 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
691 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
693 if (ip_address == NULL)
694 net_info->IpAddr.Data.Ipv4.s_addr = 0;
695 else if (inet_aton(ip_address, &(net_info->IpAddr.Data.Ipv4)) == 0)
696 return CONNECTION_ERROR_INVALID_PARAMETER;
698 return CONNECTION_ERROR_NONE;
701 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
702 connection_address_family_e address_family, const char* subnet_mask)
704 if (!(_connection_libnet_check_profile_validity(profile)) ||
705 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
706 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
707 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
708 return CONNECTION_ERROR_INVALID_PARAMETER;
711 net_profile_info_t *profile_info = profile;
712 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
713 if (net_info == NULL)
714 return CONNECTION_ERROR_OPERATION_FAILED;
716 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
717 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
719 if (subnet_mask == NULL)
720 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
721 else if (inet_aton(subnet_mask, &(net_info->SubnetMask.Data.Ipv4)) == 0)
722 return CONNECTION_ERROR_INVALID_PARAMETER;
724 return CONNECTION_ERROR_NONE;
727 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
728 connection_address_family_e address_family, const char* gateway_address)
730 if (!(_connection_libnet_check_profile_validity(profile)) ||
731 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
732 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
733 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
734 return CONNECTION_ERROR_INVALID_PARAMETER;
737 net_profile_info_t *profile_info = profile;
738 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
739 if (net_info == NULL)
740 return CONNECTION_ERROR_OPERATION_FAILED;
742 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
743 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
745 if (gateway_address == NULL)
746 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
747 else if (inet_aton(gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) == 0)
748 return CONNECTION_ERROR_INVALID_PARAMETER;
750 return CONNECTION_ERROR_NONE;
753 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
754 connection_address_family_e address_family, const char* dns_address)
756 if (!(_connection_libnet_check_profile_validity(profile)) ||
757 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
758 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
760 order > NET_DNS_ADDR_MAX) {
761 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
762 return CONNECTION_ERROR_INVALID_PARAMETER;
765 net_profile_info_t *profile_info = profile;
766 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
767 if (net_info == NULL)
768 return CONNECTION_ERROR_OPERATION_FAILED;
770 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
771 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
773 if (dns_address == NULL)
774 net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
775 else if (inet_aton(dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) == 0)
776 return CONNECTION_ERROR_INVALID_PARAMETER;
778 if (net_info->DnsCount < order)
779 net_info->DnsCount = order;
781 return CONNECTION_ERROR_NONE;
784 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
786 if (!(_connection_libnet_check_profile_validity(profile))) {
787 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
788 return CONNECTION_ERROR_INVALID_PARAMETER;
791 net_profile_info_t *profile_info = profile;
792 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
793 if (net_info == NULL)
794 return CONNECTION_ERROR_OPERATION_FAILED;
797 case CONNECTION_PROXY_TYPE_DIRECT:
798 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
800 case CONNECTION_PROXY_TYPE_AUTO:
801 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
803 case CONNECTION_PROXY_TYPE_MANUAL:
804 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
807 return CONNECTION_ERROR_INVALID_PARAMETER;
810 return CONNECTION_ERROR_NONE;
813 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
814 connection_address_family_e address_family, const char* proxy_address)
816 if (!(_connection_libnet_check_profile_validity(profile)) ||
817 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
818 address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
819 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
820 return CONNECTION_ERROR_INVALID_PARAMETER;
823 net_profile_info_t *profile_info = profile;
824 net_dev_info_t *net_info = __profile_get_net_info(profile_info);
825 if (net_info == NULL)
826 return CONNECTION_ERROR_OPERATION_FAILED;
828 if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
829 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
831 if (proxy_address == NULL)
832 net_info->ProxyAddr[0] = '\0';
834 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
836 return CONNECTION_ERROR_NONE;
839 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
840 connection_profile_state_changed_cb callback, void* user_data)
842 if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
843 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
844 return CONNECTION_ERROR_INVALID_PARAMETER;
847 if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
848 return CONNECTION_ERROR_NONE;
850 return CONNECTION_ERROR_OPERATION_FAILED;
853 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
855 if (!(_connection_libnet_check_profile_cb_validity(profile))) {
856 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
857 return CONNECTION_ERROR_INVALID_PARAMETER;
860 if (_connection_libnet_remove_from_profile_cb_list(profile) != true)
861 return CONNECTION_ERROR_INVALID_PARAMETER;
863 return CONNECTION_ERROR_NONE;
867 /* Wi-Fi profile *************************************************************/
868 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
870 if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
871 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
872 return CONNECTION_ERROR_INVALID_PARAMETER;
875 net_profile_info_t *profile_info = profile;
877 if (profile_info->profile_type != NET_DEVICE_WIFI)
878 return CONNECTION_ERROR_INVALID_PARAMETER;
880 *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
882 return CONNECTION_ERROR_OUT_OF_MEMORY;
884 return CONNECTION_ERROR_NONE;
887 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
889 if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
890 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
891 return CONNECTION_ERROR_INVALID_PARAMETER;
894 net_profile_info_t *profile_info = profile;
896 if (profile_info->profile_type != NET_DEVICE_WIFI)
897 return CONNECTION_ERROR_INVALID_PARAMETER;
899 *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
901 return CONNECTION_ERROR_OUT_OF_MEMORY;
903 return CONNECTION_ERROR_NONE;
906 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
908 if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
909 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
910 return CONNECTION_ERROR_INVALID_PARAMETER;
913 net_profile_info_t *profile_info = profile;
915 if (profile_info->profile_type != NET_DEVICE_WIFI)
916 return CONNECTION_ERROR_INVALID_PARAMETER;
918 *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
920 return CONNECTION_ERROR_NONE;
923 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
925 if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
926 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
927 return CONNECTION_ERROR_INVALID_PARAMETER;
930 net_profile_info_t *profile_info = profile;
932 if (profile_info->profile_type != NET_DEVICE_WIFI)
933 return CONNECTION_ERROR_INVALID_PARAMETER;
935 *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
937 return CONNECTION_ERROR_NONE;
940 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
942 if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
943 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
944 return CONNECTION_ERROR_INVALID_PARAMETER;
947 net_profile_info_t *profile_info = profile;
949 if (profile_info->profile_type != NET_DEVICE_WIFI)
950 return CONNECTION_ERROR_INVALID_PARAMETER;
952 *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate;
954 return CONNECTION_ERROR_NONE;
957 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e* type)
959 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
960 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
961 return CONNECTION_ERROR_INVALID_PARAMETER;
964 net_profile_info_t *profile_info = profile;
966 if (profile_info->profile_type != NET_DEVICE_WIFI)
967 return CONNECTION_ERROR_INVALID_PARAMETER;
969 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
970 case WLAN_SEC_MODE_NONE:
971 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
973 case WLAN_SEC_MODE_WEP:
974 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
976 case WLAN_SEC_MODE_IEEE8021X:
977 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
979 case WLAN_SEC_MODE_WPA_PSK:
980 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
982 case WLAN_SEC_MODE_WPA2_PSK:
983 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
986 return CONNECTION_ERROR_OPERATION_FAILED;
989 return CONNECTION_ERROR_NONE;
992 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e* type)
994 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
995 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
996 return CONNECTION_ERROR_INVALID_PARAMETER;
999 net_profile_info_t *profile_info = profile;
1001 if (profile_info->profile_type != NET_DEVICE_WIFI)
1002 return CONNECTION_ERROR_INVALID_PARAMETER;
1004 switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1005 case WLAN_ENC_MODE_NONE:
1006 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1008 case WLAN_ENC_MODE_WEP:
1009 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1011 case WLAN_ENC_MODE_TKIP:
1012 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1014 case WLAN_ENC_MODE_AES:
1015 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1017 case WLAN_ENC_MODE_TKIP_AES_MIXED:
1018 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1021 return CONNECTION_ERROR_OPERATION_FAILED;
1024 return CONNECTION_ERROR_NONE;
1027 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1029 if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1030 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1031 return CONNECTION_ERROR_INVALID_PARAMETER;
1034 net_profile_info_t *profile_info = profile;
1036 if (profile_info->profile_type != NET_DEVICE_WIFI)
1037 return CONNECTION_ERROR_INVALID_PARAMETER;
1039 if (profile_info->Favourite) {
1041 return CONNECTION_ERROR_NONE;
1044 switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1045 case WLAN_SEC_MODE_NONE:
1048 case WLAN_SEC_MODE_WEP:
1049 case WLAN_SEC_MODE_IEEE8021X:
1050 case WLAN_SEC_MODE_WPA_PSK:
1051 case WLAN_SEC_MODE_WPA2_PSK:
1055 return CONNECTION_ERROR_OPERATION_FAILED;
1058 return CONNECTION_ERROR_NONE;
1061 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1063 if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1064 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1065 return CONNECTION_ERROR_INVALID_PARAMETER;
1068 net_profile_info_t *profile_info = profile;
1070 if (profile_info->profile_type != NET_DEVICE_WIFI)
1071 return CONNECTION_ERROR_INVALID_PARAMETER;
1073 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1074 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1076 return CONNECTION_ERROR_NONE;
1079 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1081 if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1082 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1083 return CONNECTION_ERROR_INVALID_PARAMETER;
1086 net_profile_info_t *profile_info = profile;
1088 if (profile_info->profile_type != NET_DEVICE_WIFI)
1089 return CONNECTION_ERROR_INVALID_PARAMETER;
1091 if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1096 return CONNECTION_ERROR_NONE;
1100 /* Cellular profile **********************************************************/
1101 EXPORT_API int connection_profile_get_cellular_network_type(connection_profile_h profile, connection_cellular_network_type_e* type)
1103 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1104 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1105 return CONNECTION_ERROR_INVALID_PARAMETER;
1109 net_profile_info_t *profile_info = profile;
1111 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1112 return CONNECTION_ERROR_INVALID_PARAMETER;
1114 if (vconf_get_int(VCONFKEY_TELEPHONY_SVC_ACT, &network_type)) {
1115 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed\n");
1116 return CONNECTION_ERROR_OPERATION_FAILED;
1119 CONNECTION_LOG(CONNECTION_INFO, "Cellular network type = %d\n", network_type);
1121 switch (network_type) {
1122 case VCONFKEY_TELEPHONY_SVC_ACT_NONE:
1123 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UNKNOWN;
1125 case VCONFKEY_TELEPHONY_SVC_ACT_GPRS:
1126 *type = CONNECTION_CELLULAR_NETWORK_TYPE_GPRS;
1128 case VCONFKEY_TELEPHONY_SVC_ACT_EGPRS:
1129 *type = CONNECTION_CELLULAR_NETWORK_TYPE_EDGE;
1131 case VCONFKEY_TELEPHONY_SVC_ACT_UMTS:
1132 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UMTS;
1135 return CONNECTION_ERROR_OPERATION_FAILED;
1138 return CONNECTION_ERROR_NONE;
1141 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1142 connection_cellular_service_type_e* type)
1144 if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1145 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1146 return CONNECTION_ERROR_INVALID_PARAMETER;
1149 net_profile_info_t *profile_info = profile;
1151 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1152 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type Passed\n");
1153 return CONNECTION_ERROR_INVALID_PARAMETER;
1156 *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1158 if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1159 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed\n");
1160 return CONNECTION_ERROR_OPERATION_FAILED;
1163 return CONNECTION_ERROR_NONE;
1166 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1168 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1169 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1170 return CONNECTION_ERROR_INVALID_PARAMETER;
1173 net_profile_info_t *profile_info = profile;
1175 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1176 return CONNECTION_ERROR_INVALID_PARAMETER;
1178 *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1180 return CONNECTION_ERROR_OUT_OF_MEMORY;
1182 return CONNECTION_ERROR_NONE;
1185 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1186 connection_cellular_auth_type_e* type, char** user_name, char** password)
1188 if (!(_connection_libnet_check_profile_validity(profile)) ||
1189 type == NULL || user_name == NULL || password == NULL) {
1190 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1191 return CONNECTION_ERROR_INVALID_PARAMETER;
1194 net_profile_info_t *profile_info = profile;
1196 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1197 return CONNECTION_ERROR_INVALID_PARAMETER;
1199 switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1200 case NET_PDP_AUTH_NONE:
1201 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1203 case NET_PDP_AUTH_PAP:
1204 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1206 case NET_PDP_AUTH_CHAP:
1207 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1210 return CONNECTION_ERROR_OPERATION_FAILED;
1213 *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1214 if (*user_name == NULL)
1215 return CONNECTION_ERROR_OUT_OF_MEMORY;
1217 *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1218 if (*password == NULL) {
1220 return CONNECTION_ERROR_OUT_OF_MEMORY;
1223 return CONNECTION_ERROR_NONE;
1226 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1228 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1229 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1230 return CONNECTION_ERROR_INVALID_PARAMETER;
1233 net_profile_info_t *profile_info = profile;
1235 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1236 return CONNECTION_ERROR_INVALID_PARAMETER;
1238 *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1239 if (*home_url == NULL)
1240 return CONNECTION_ERROR_OUT_OF_MEMORY;
1242 return CONNECTION_ERROR_NONE;
1245 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1247 if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1248 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1249 return CONNECTION_ERROR_INVALID_PARAMETER;
1252 net_profile_info_t *profile_info = profile;
1254 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1255 return CONNECTION_ERROR_INVALID_PARAMETER;
1257 if (profile_info->ProfileInfo.Pdp.Roaming)
1260 *is_roaming = false;
1262 return CONNECTION_ERROR_NONE;
1265 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
1267 if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
1268 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1269 return CONNECTION_ERROR_INVALID_PARAMETER;
1272 net_profile_info_t *profile_info = profile;
1274 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1275 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1276 return CONNECTION_ERROR_INVALID_PARAMETER;
1279 if (profile_info->ProfileInfo.Pdp.Hidden)
1284 return CONNECTION_ERROR_NONE;
1287 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
1289 if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
1290 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1291 return CONNECTION_ERROR_INVALID_PARAMETER;
1294 net_profile_info_t *profile_info = profile;
1296 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1297 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1298 return CONNECTION_ERROR_INVALID_PARAMETER;
1301 if (profile_info->ProfileInfo.Pdp.Editable)
1302 *is_editable = true;
1304 *is_editable = false;
1306 return CONNECTION_ERROR_NONE;
1309 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
1311 if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
1312 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1313 return CONNECTION_ERROR_INVALID_PARAMETER;
1316 net_profile_info_t *profile_info = profile;
1318 if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1319 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1320 return CONNECTION_ERROR_INVALID_PARAMETER;
1323 if (profile_info->ProfileInfo.Pdp.DefaultConn)
1326 *is_default = false;
1328 return CONNECTION_ERROR_NONE;
1331 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
1332 connection_cellular_service_type_e service_type)
1334 if (!(_connection_libnet_check_profile_validity(profile))) {
1335 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1336 return CONNECTION_ERROR_INVALID_PARAMETER;
1339 net_profile_info_t *profile_info = profile;
1341 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1342 return CONNECTION_ERROR_INVALID_PARAMETER;
1344 switch (service_type) {
1345 case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1346 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1348 case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1349 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1351 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1352 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1354 case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1355 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1357 case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1358 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1360 case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1361 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1363 case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1365 return CONNECTION_ERROR_INVALID_PARAMETER;
1368 return CONNECTION_ERROR_NONE;
1371 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1373 if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1374 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1375 return CONNECTION_ERROR_INVALID_PARAMETER;
1378 net_profile_info_t *profile_info = profile;
1380 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1381 return CONNECTION_ERROR_INVALID_PARAMETER;
1383 g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1385 return CONNECTION_ERROR_NONE;
1388 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1389 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1391 if (!(_connection_libnet_check_profile_validity(profile)) ||
1392 user_name == NULL || password == NULL) {
1393 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1394 return CONNECTION_ERROR_INVALID_PARAMETER;
1397 net_profile_info_t *profile_info = profile;
1399 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1400 return CONNECTION_ERROR_INVALID_PARAMETER;
1403 case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1404 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1406 case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1407 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1409 case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1410 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1413 return CONNECTION_ERROR_INVALID_PARAMETER;
1416 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1417 g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1419 return CONNECTION_ERROR_NONE;
1422 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1424 if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1425 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1426 return CONNECTION_ERROR_INVALID_PARAMETER;
1429 net_profile_info_t *profile_info = profile;
1431 if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1432 return CONNECTION_ERROR_INVALID_PARAMETER;
1434 g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1436 return CONNECTION_ERROR_NONE;