src/connection_profile.c

   1 /*
   2  * Copyright (c) 2011-2013 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   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
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 #include <stdio.h>
  18 #include <string.h>
  19 #include <stdlib.h>
  20 #include <arpa/inet.h>
  21 #include <glib.h>
  22 #include <vconf/vconf.h>
  23 #include "net_connection_private.h"
  24
  25 #define HTTP_PROXY "http_proxy"
  26 #define MAX_PREFIX_LENGTH 6
  27
  28 static net_dev_info_t* __profile_get_net_info(net_profile_info_t *profile_info)
  29 {
  30         switch (profile_info->profile_type) {
  31         case NET_DEVICE_CELLULAR:
  32                 return &profile_info->ProfileInfo.Pdp.net_info;
  33         case NET_DEVICE_WIFI:
  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:
  40         case NET_DEVICE_USB:
  41         case NET_DEVICE_UNKNOWN:
  42         case NET_DEVICE_MAX:
  43         default:
  44                 return NULL;
  45         }
  46 }
  47
  48 static char *__profile_convert_ip_to_string(net_addr_t *ip_addr, connection_address_family_e address_family)
  49 {
  50         unsigned char *ipaddr = NULL;
  51         char *ipstr = NULL;
  52
  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);
  56                 if (ipstr == NULL)
  57                         return NULL;
  58
  59                 inet_ntop(AF_INET, ipaddr, ipstr, INET_ADDRSTRLEN);
  60         } else {
  61                 ipaddr = (unsigned char *)&ip_addr->Data.Ipv6.s6_addr;
  62                 ipstr = g_try_malloc0(INET6_ADDRSTRLEN);
  63                 if (ipstr == NULL)
  64                                 return NULL;
  65
  66                 inet_ntop(AF_INET6, ipaddr, ipstr, INET6_ADDRSTRLEN);
  67         }
  68
  69         return ipstr;
  70 }
  71
  72 static void __profile_init_cellular_profile(net_profile_info_t *profile_info, const char *keyword)
  73 {
  74         int default_subscriber_id = 0;
  75         connection_profile_h profile = NULL;
  76
  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);
  82
  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");
  87
  88         profile = (connection_profile_h)profile_info;
  89         _connection_libnet_set_cellular_subscriber_id(profile, default_subscriber_id);
  90 }
  91
  92 static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
  93 {
  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;
 101 }
 102
 103 static const char* __profile_get_ethernet_proxy(void)
 104 {
 105         char *proxy;
 106
 107         proxy = getenv(HTTP_PROXY);
 108
 109         if(proxy == NULL) {
 110                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
 111                 return NULL;
 112         }
 113
 114         return proxy;
 115 }
 116
 117 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
 118 {
 119         switch (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;
 132         default:
 133                 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
 134         }
 135 }
 136
 137 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
 138 {
 139         connection_profile_state_e cp_state;
 140
 141         switch (state) {
 142         case NET_STATE_TYPE_ONLINE:
 143         case NET_STATE_TYPE_READY:
 144                 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
 145                 break;
 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;
 150                 break;
 151         case NET_STATE_TYPE_ASSOCIATION:
 152                 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
 153                 break;
 154         case NET_STATE_TYPE_CONFIGURATION:
 155                 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
 156                 break;
 157         default:
 158                 cp_state = -1;
 159         }
 160
 161         return cp_state;
 162 }
 163
 164 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
 165 {
 166         switch (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;
 179         default:
 180                 return NET_SERVICE_UNKNOWN;
 181         }
 182 }
 183
 184 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
 185 {
 186         net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
 187
 188         switch (state) {
 189         case CONNECTION_PROFILE_STATE_CONNECTED:
 190                 libnet_state = NET_STATE_TYPE_ONLINE;
 191                 break;
 192         case CONNECTION_PROFILE_STATE_DISCONNECTED:
 193                 libnet_state = NET_STATE_TYPE_IDLE;
 194                 break;
 195         case CONNECTION_PROFILE_STATE_ASSOCIATION:
 196                 libnet_state = NET_STATE_TYPE_ASSOCIATION;
 197                 break;
 198         case CONNECTION_PROFILE_STATE_CONFIGURATION:
 199                 libnet_state = NET_STATE_TYPE_CONFIGURATION;
 200                 break;
 201         }
 202
 203         return libnet_state;
 204 }
 205
 206
 207 /* Connection profile ********************************************************/
 208 EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
 209 {
 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;
 214         }
 215
 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;
 219
 220         switch (type) {
 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;
 226                 }
 227                 __profile_init_cellular_profile(profile_info, keyword);
 228                 break;
 229         case CONNECTION_PROFILE_TYPE_WIFI:
 230                 __profile_init_wifi_profile(profile_info);
 231                 break;
 232         default:
 233                 break;
 234         }
 235
 236         *profile = (connection_profile_h)profile_info;
 237         _connection_libnet_add_to_profile_list(*profile);
 238
 239         return CONNECTION_ERROR_NONE;
 240 }
 241
 242 EXPORT_API int connection_profile_destroy(connection_profile_h profile)
 243 {
 244         if (!(_connection_libnet_check_profile_validity(profile))) {
 245                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 246                 return CONNECTION_ERROR_INVALID_PARAMETER;
 247         }
 248
 249         _connection_libnet_remove_from_profile_list(profile);
 250
 251         return CONNECTION_ERROR_NONE;
 252 }
 253
 254 EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
 255 {
 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;
 259         }
 260
 261         *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
 262         if (*cloned_profile == NULL)
 263                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 264
 265         memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
 266         _connection_libnet_add_to_profile_list(*cloned_profile);
 267
 268         return CONNECTION_ERROR_NONE;
 269 }
 270
 271 EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
 272 {
 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;
 276         }
 277
 278         net_profile_info_t *profile_info = profile;
 279
 280         char *prof_id = strrchr(profile_info->ProfileName, '/');
 281         if (prof_id == NULL)
 282                 return CONNECTION_ERROR_INVALID_PARAMETER;
 283
 284         prof_id++;
 285         *profile_id = g_strdup(prof_id);
 286
 287         if (*profile_id == NULL)
 288                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 289
 290         return CONNECTION_ERROR_NONE;
 291 }
 292
 293 EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
 294 {
 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;
 298         }
 299
 300         net_profile_info_t *profile_info = profile;
 301
 302         switch (profile_info->profile_type) {
 303         case NET_DEVICE_CELLULAR:
 304                 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
 305                 break;
 306         case NET_DEVICE_WIFI:
 307                 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
 308                 break;
 309         case NET_DEVICE_ETHERNET:
 310                 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName);
 311                 break;
 312         case NET_DEVICE_BLUETOOTH: {
 313                 char *bt_name = strrchr(profile_info->ProfileName, '/');
 314                 if (bt_name == NULL)
 315                         return CONNECTION_ERROR_INVALID_PARAMETER;
 316
 317                 bt_name++;
 318                 *profile_name = g_strdup(bt_name);
 319         } break;
 320         default:
 321                 return CONNECTION_ERROR_INVALID_PARAMETER;
 322         }
 323
 324         if (*profile_name == NULL)
 325                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 326
 327         return CONNECTION_ERROR_NONE;
 328 }
 329
 330 EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e* type)
 331 {
 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;
 335         }
 336
 337         net_profile_info_t *profile_info = profile;
 338
 339         switch (profile_info->profile_type) {
 340         case NET_DEVICE_CELLULAR:
 341                 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
 342                 break;
 343         case NET_DEVICE_WIFI:
 344                 *type = CONNECTION_PROFILE_TYPE_WIFI;
 345                 break;
 346         case NET_DEVICE_ETHERNET:
 347                 *type = CONNECTION_PROFILE_TYPE_ETHERNET;
 348                 break;
 349         case NET_DEVICE_BLUETOOTH:
 350                 *type = CONNECTION_PROFILE_TYPE_BT;
 351                 break;
 352         default:
 353                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type\n");
 354                 return CONNECTION_ERROR_OPERATION_FAILED;
 355         }
 356
 357         return CONNECTION_ERROR_NONE;
 358 }
 359
 360 EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
 361 {
 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;
 365         }
 366
 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;
 371
 372         *interface_name = g_strdup(net_info->DevName);
 373         if (*interface_name == NULL)
 374                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 375
 376         return CONNECTION_ERROR_NONE;
 377 }
 378
 379 EXPORT_API int connection_profile_refresh(connection_profile_h profile)
 380 {
 381         int rv;
 382         if (!(_connection_libnet_check_profile_validity(profile))) {
 383                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 384                 return CONNECTION_ERROR_INVALID_PARAMETER;
 385         }
 386
 387         net_profile_info_t profile_info_local;
 388         net_profile_info_t *profile_info = profile;
 389
 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;
 397         }
 398
 399         memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
 400
 401         return CONNECTION_ERROR_NONE;
 402 }
 403
 404 EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
 405 {
 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;
 409         }
 410
 411         net_profile_info_t *profile_info = profile;
 412         *state = _profile_convert_to_cp_state(profile_info->ProfileState);
 413         if (*state < 0)
 414                 return CONNECTION_ERROR_OPERATION_FAILED;
 415
 416         return CONNECTION_ERROR_NONE;
 417 }
 418
 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)
 421 {
 422         net_ip_config_type_t profile_type;
 423
 424         if (!(_connection_libnet_check_profile_validity(profile)) ||
 425             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 426              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 427             type == NULL) {
 428                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 429                 return CONNECTION_ERROR_INVALID_PARAMETER;
 430         }
 431
 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;
 436
 437         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 438                 profile_type = net_info->IpConfigType;
 439         else
 440                 profile_type = net_info->IpConfigType6;
 441
 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;
 446                         break;
 447
 448                 case NET_IP_CONFIG_TYPE_DYNAMIC:
 449                         *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
 450                         break;
 451
 452                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 453                         *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 454                         break;
 455
 456                 case NET_IP_CONFIG_TYPE_FIXED:
 457                         *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
 458                         break;
 459
 460                 case NET_IP_CONFIG_TYPE_OFF:
 461                         *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 462                         break;
 463                 default:
 464                         return CONNECTION_ERROR_OPERATION_FAILED;
 465                 }
 466         } else {
 467                 switch (profile_type) {
 468                 case NET_IP_CONFIG_TYPE_STATIC:
 469                         *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 470                         break;
 471
 472                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 473                         *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 474                         break;
 475
 476                 case NET_IP_CONFIG_TYPE_OFF:
 477                         *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 478                         break;
 479
 480                 default:
 481                         return  CONNECTION_ERROR_OPERATION_FAILED;
 482
 483                 }
 484         }
 485
 486         return CONNECTION_ERROR_NONE;
 487 }
 488
 489 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
 490                 connection_address_family_e address_family, char** ip_address)
 491 {
 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;
 498         }
 499
 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;
 504
 505         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 506                 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr6,
 507                                 address_family);
 508         else
 509                 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
 510                                 address_family);
 511
 512         if (*ip_address == NULL)
 513                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 514
 515         return CONNECTION_ERROR_NONE;
 516 }
 517
 518 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
 519                 connection_address_family_e address_family, char** subnet_mask)
 520 {
 521         char* prefixlen;
 522
 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;
 529         }
 530
 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;
 535
 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;
 540         } else
 541                 *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask,
 542                                 address_family);
 543
 544         if (*subnet_mask == NULL)
 545                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 546
 547         return CONNECTION_ERROR_NONE;
 548 }
 549
 550 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
 551                 connection_address_family_e address_family, char** gateway_address)
 552 {
 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;
 559         }
 560
 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;
 565
 566         if(address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 567                 *gateway_address = __profile_convert_ip_to_string(
 568                                         &net_info->GatewayAddr6, address_family);
 569         else
 570                 *gateway_address = __profile_convert_ip_to_string(
 571                                         &net_info->GatewayAddr, address_family);
 572
 573         if (*gateway_address == NULL)
 574                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 575
 576         return CONNECTION_ERROR_NONE;
 577 }
 578
 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)
 581 {
 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 ||
 586             order <= 0 ||
 587             order > NET_DNS_ADDR_MAX) {
 588                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 589                 return CONNECTION_ERROR_INVALID_PARAMETER;
 590         }
 591
 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;
 596
 597         if(address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 598                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
 599                                 address_family);
 600         else if(address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 601                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1],
 602                                 address_family);
 603         else
 604                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid address family\n");
 605
 606         if (*dns_address == NULL)
 607                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 608
 609         return CONNECTION_ERROR_NONE;
 610 }
 611
 612 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e* type)
 613 {
 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;
 617         }
 618
 619         const char *proxy;
 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;
 624
 625         if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
 626                 proxy = __profile_get_ethernet_proxy();
 627                 if (proxy == NULL)
 628                         *type = CONNECTION_PROXY_TYPE_DIRECT;
 629                 else
 630                         *type = CONNECTION_PROXY_TYPE_MANUAL;
 631
 632                 return CONNECTION_ERROR_NONE;
 633         }
 634
 635         switch (net_info->ProxyMethod) {
 636         case NET_PROXY_TYPE_DIRECT:
 637                 *type = CONNECTION_PROXY_TYPE_DIRECT;
 638                 break;
 639         case NET_PROXY_TYPE_AUTO:
 640                 *type = CONNECTION_PROXY_TYPE_AUTO;
 641                 break;
 642         case NET_PROXY_TYPE_MANUAL:
 643                 *type = CONNECTION_PROXY_TYPE_MANUAL;
 644                 break;
 645         case NET_PROXY_TYPE_UNKNOWN:
 646         default:
 647                 return CONNECTION_ERROR_OPERATION_FAILED;
 648         }
 649
 650         return CONNECTION_ERROR_NONE;
 651 }
 652
 653 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
 654                 connection_address_family_e address_family, char** proxy_address)
 655 {
 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;
 662         }
 663
 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;
 668
 669         *proxy_address = g_strdup(net_info->ProxyAddr);
 670
 671         if (*proxy_address == NULL)
 672                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 673
 674         return CONNECTION_ERROR_NONE;
 675 }
 676
 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)
 679 {
 680         net_ip_config_type_t *profile_type = NULL;
 681
 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;
 687         }
 688
 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;
 693
 694         if(address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 695                 profile_type = &net_info->IpConfigType ;
 696         else
 697                 profile_type = &net_info->IpConfigType6 ;
 698
 699         if(address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
 700                 switch (type) {
 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 ;
 706                         break;
 707
 708                 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
 709                         *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
 710                         break;
 711
 712                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
 713                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
 714                         break;
 715
 716                 case CONNECTION_IP_CONFIG_TYPE_FIXED:
 717                         net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
 718                         break;
 719
 720                 case CONNECTION_IP_CONFIG_TYPE_NONE:
 721                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
 722                         break;
 723
 724                 default:
 725                         return CONNECTION_ERROR_INVALID_PARAMETER;
 726                 }
 727         } else {
 728                 switch (type) {
 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);
 735                         break;
 736
 737                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
 738                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
 739                         break;
 740
 741                 case CONNECTION_IP_CONFIG_TYPE_NONE:
 742                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
 743                         break;
 744
 745                 default:
 746                         return CONNECTION_ERROR_INVALID_PARAMETER;
 747                 }
 748         }
 749
 750         return CONNECTION_ERROR_NONE;
 751 }
 752
 753 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
 754                 connection_address_family_e address_family, const char* ip_address)
 755 {
 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;
 761         }
 762
 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;
 767
 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;
 774         } else {
 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;
 780         }
 781
 782         return CONNECTION_ERROR_NONE;
 783 }
 784
 785 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
 786                 connection_address_family_e address_family, const char* subnet_mask)
 787 {
 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;
 793         }
 794
 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;
 799
 800         if(address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 801                 if (subnet_mask == NULL)
 802                         net_info->PrefixLen6 = 0 ;
 803                 else
 804                         net_info->PrefixLen6 = atoi(subnet_mask) ;
 805         } else {
 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;
 810         }
 811
 812         return CONNECTION_ERROR_NONE;
 813 }
 814
 815 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
 816                 connection_address_family_e address_family, const char* gateway_address)
 817 {
 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;
 823         }
 824
 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;
 829
 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;
 835         } else {
 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;
 840         }
 841
 842         return CONNECTION_ERROR_NONE;
 843 }
 844
 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)
 847 {
 848         if (!(_connection_libnet_check_profile_validity(profile)) ||
 849             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 850              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 851             order <= 0 ||
 852             order > NET_DNS_ADDR_MAX) {
 853                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 854                 return CONNECTION_ERROR_INVALID_PARAMETER;
 855         }
 856
 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;
 861
 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;
 870         } else {
 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;
 878         }
 879
 880         return CONNECTION_ERROR_NONE;
 881 }
 882
 883 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
 884 {
 885         if (!(_connection_libnet_check_profile_validity(profile))) {
 886                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 887                 return CONNECTION_ERROR_INVALID_PARAMETER;
 888         }
 889
 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;
 894
 895         switch (type) {
 896         case CONNECTION_PROXY_TYPE_DIRECT:
 897                 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
 898                 break;
 899         case CONNECTION_PROXY_TYPE_AUTO:
 900                 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
 901                 break;
 902         case CONNECTION_PROXY_TYPE_MANUAL:
 903                 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
 904                 break;
 905         default:
 906                 return CONNECTION_ERROR_INVALID_PARAMETER;
 907         }
 908
 909         return CONNECTION_ERROR_NONE;
 910 }
 911
 912 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
 913                 connection_address_family_e address_family, const char* proxy_address)
 914 {
 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;
 920         }
 921
 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;
 926
 927         if (proxy_address == NULL)
 928                 net_info->ProxyAddr[0] = '\0';
 929         else
 930                 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
 931
 932         return CONNECTION_ERROR_NONE;
 933 }
 934
 935 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
 936                 connection_profile_state_changed_cb callback, void* user_data)
 937 {
 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;
 941         }
 942
 943         if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
 944                 return CONNECTION_ERROR_NONE;
 945
 946         return CONNECTION_ERROR_OPERATION_FAILED;
 947 }
 948
 949 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
 950 {
 951         if (!(_connection_libnet_check_profile_cb_validity(profile))) {
 952                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 953                 return CONNECTION_ERROR_INVALID_PARAMETER;
 954         }
 955
 956         if (_connection_libnet_remove_from_profile_cb_list(profile) != true)
 957                 return CONNECTION_ERROR_INVALID_PARAMETER;
 958
 959         return CONNECTION_ERROR_NONE;
 960 }
 961
 962
 963 /* Wi-Fi profile *************************************************************/
 964 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
 965 {
 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;
 969         }
 970
 971         net_profile_info_t *profile_info = profile;
 972
 973         if (profile_info->profile_type != NET_DEVICE_WIFI)
 974                 return CONNECTION_ERROR_INVALID_PARAMETER;
 975
 976         *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
 977         if (*essid == NULL)
 978                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 979
 980         return CONNECTION_ERROR_NONE;
 981 }
 982
 983 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
 984 {
 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;
 988         }
 989
 990         net_profile_info_t *profile_info = profile;
 991
 992         if (profile_info->profile_type != NET_DEVICE_WIFI)
 993                 return CONNECTION_ERROR_INVALID_PARAMETER;
 994
 995         *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
 996         if (*bssid == NULL)
 997                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 998
 999         return CONNECTION_ERROR_NONE;
1000 }
1001
1002 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1003 {
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;
1007         }
1008
1009         net_profile_info_t *profile_info = profile;
1010
1011         if (profile_info->profile_type != NET_DEVICE_WIFI)
1012                 return CONNECTION_ERROR_INVALID_PARAMETER;
1013
1014         *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1015
1016         return CONNECTION_ERROR_NONE;
1017 }
1018
1019 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1020 {
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;
1024         }
1025
1026         net_profile_info_t *profile_info = profile;
1027
1028         if (profile_info->profile_type != NET_DEVICE_WIFI)
1029                 return CONNECTION_ERROR_INVALID_PARAMETER;
1030
1031         *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1032
1033         return CONNECTION_ERROR_NONE;
1034 }
1035
1036 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1037 {
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;
1041         }
1042
1043         net_profile_info_t *profile_info = profile;
1044
1045         if (profile_info->profile_type != NET_DEVICE_WIFI)
1046                 return CONNECTION_ERROR_INVALID_PARAMETER;
1047
1048         *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate;
1049
1050         return CONNECTION_ERROR_NONE;
1051 }
1052
1053 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e* type)
1054 {
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;
1058         }
1059
1060         net_profile_info_t *profile_info = profile;
1061
1062         if (profile_info->profile_type != NET_DEVICE_WIFI)
1063                 return CONNECTION_ERROR_INVALID_PARAMETER;
1064
1065         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1066         case WLAN_SEC_MODE_NONE:
1067                 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1068                 break;
1069         case WLAN_SEC_MODE_WEP:
1070                 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1071                 break;
1072         case WLAN_SEC_MODE_IEEE8021X:
1073                 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1074                 break;
1075         case WLAN_SEC_MODE_WPA_PSK:
1076                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1077                 break;
1078         case WLAN_SEC_MODE_WPA2_PSK:
1079                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1080                 break;
1081         default:
1082                 return CONNECTION_ERROR_OPERATION_FAILED;
1083         }
1084
1085         return CONNECTION_ERROR_NONE;
1086 }
1087
1088 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e* type)
1089 {
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;
1093         }
1094
1095         net_profile_info_t *profile_info = profile;
1096
1097         if (profile_info->profile_type != NET_DEVICE_WIFI)
1098                 return CONNECTION_ERROR_INVALID_PARAMETER;
1099
1100         switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1101         case WLAN_ENC_MODE_NONE:
1102                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1103                 break;
1104         case WLAN_ENC_MODE_WEP:
1105                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1106                 break;
1107         case WLAN_ENC_MODE_TKIP:
1108                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1109                 break;
1110         case WLAN_ENC_MODE_AES:
1111                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1112                 break;
1113         case WLAN_ENC_MODE_TKIP_AES_MIXED:
1114                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1115                 break;
1116         default:
1117                 return CONNECTION_ERROR_OPERATION_FAILED;
1118         }
1119
1120         return CONNECTION_ERROR_NONE;
1121 }
1122
1123 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1124 {
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;
1128         }
1129
1130         net_profile_info_t *profile_info = profile;
1131
1132         if (profile_info->profile_type != NET_DEVICE_WIFI)
1133                 return CONNECTION_ERROR_INVALID_PARAMETER;
1134
1135         if (profile_info->Favourite) {
1136                 *required = false;
1137                 return CONNECTION_ERROR_NONE;
1138         }
1139
1140         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1141         case WLAN_SEC_MODE_NONE:
1142                 *required = false;
1143                 break;
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:
1148                 *required = true;
1149                 break;
1150         default:
1151                 return CONNECTION_ERROR_OPERATION_FAILED;
1152         }
1153
1154         return CONNECTION_ERROR_NONE;
1155 }
1156
1157 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1158 {
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;
1162         }
1163
1164         net_profile_info_t *profile_info = profile;
1165
1166         if (profile_info->profile_type != NET_DEVICE_WIFI)
1167                 return CONNECTION_ERROR_INVALID_PARAMETER;
1168
1169         g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1170                                                 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1171
1172         return CONNECTION_ERROR_NONE;
1173 }
1174
1175 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1176 {
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;
1180         }
1181
1182         net_profile_info_t *profile_info = profile;
1183
1184         if (profile_info->profile_type != NET_DEVICE_WIFI)
1185                 return CONNECTION_ERROR_INVALID_PARAMETER;
1186
1187         if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1188                 *supported = true;
1189         else
1190                 *supported = false;
1191
1192         return CONNECTION_ERROR_NONE;
1193 }
1194
1195
1196 /* Cellular profile **********************************************************/
1197 EXPORT_API int connection_profile_get_cellular_network_type(connection_profile_h profile, connection_cellular_network_type_e* type)
1198 {
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;
1202         }
1203
1204         int network_type;
1205         net_profile_info_t *profile_info = profile;
1206
1207         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1208                 return CONNECTION_ERROR_INVALID_PARAMETER;
1209
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;
1213         }
1214
1215         CONNECTION_LOG(CONNECTION_INFO, "Cellular network type = %d\n", network_type);
1216
1217         switch (network_type) {
1218         case VCONFKEY_TELEPHONY_SVC_ACT_NONE:
1219                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UNKNOWN;
1220                 break;
1221         case VCONFKEY_TELEPHONY_SVC_ACT_GPRS:
1222                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_GPRS;
1223                 break;
1224         case VCONFKEY_TELEPHONY_SVC_ACT_EGPRS:
1225                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_EDGE;
1226                 break;
1227         case VCONFKEY_TELEPHONY_SVC_ACT_UMTS:
1228                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UMTS;
1229                 break;
1230         default:
1231                 return CONNECTION_ERROR_OPERATION_FAILED;
1232         }
1233
1234         return CONNECTION_ERROR_NONE;
1235 }
1236
1237 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1238                                                 connection_cellular_service_type_e* type)
1239 {
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;
1243         }
1244
1245         net_profile_info_t *profile_info = profile;
1246
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;
1250         }
1251
1252         *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1253
1254         if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1255                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed\n");
1256                 return CONNECTION_ERROR_OPERATION_FAILED;
1257         }
1258
1259         return CONNECTION_ERROR_NONE;
1260 }
1261
1262 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1263 {
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;
1267         }
1268
1269         net_profile_info_t *profile_info = profile;
1270
1271         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1272                 return CONNECTION_ERROR_INVALID_PARAMETER;
1273
1274         *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1275         if (*apn == NULL)
1276                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1277
1278         return CONNECTION_ERROR_NONE;
1279 }
1280
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)
1283 {
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;
1288         }
1289
1290         net_profile_info_t *profile_info = profile;
1291
1292         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1293                 return CONNECTION_ERROR_INVALID_PARAMETER;
1294
1295         switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1296         case NET_PDP_AUTH_NONE:
1297                 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1298                 break;
1299         case NET_PDP_AUTH_PAP:
1300                 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1301                 break;
1302         case NET_PDP_AUTH_CHAP:
1303                 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1304                 break;
1305         default:
1306                 return CONNECTION_ERROR_OPERATION_FAILED;
1307         }
1308
1309         *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1310         if (*user_name == NULL)
1311                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1312
1313         *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1314         if (*password == NULL) {
1315                 g_free(*user_name);
1316                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1317         }
1318
1319         return CONNECTION_ERROR_NONE;
1320 }
1321
1322 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1323 {
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;
1327         }
1328
1329         net_profile_info_t *profile_info = profile;
1330
1331         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1332                 return CONNECTION_ERROR_INVALID_PARAMETER;
1333
1334         *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1335         if (*home_url == NULL)
1336                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1337
1338         return CONNECTION_ERROR_NONE;
1339 }
1340
1341 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1342 {
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;
1346         }
1347
1348         net_profile_info_t *profile_info = profile;
1349
1350         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1351                 return CONNECTION_ERROR_INVALID_PARAMETER;
1352
1353         if (profile_info->ProfileInfo.Pdp.Roaming)
1354                 *is_roaming = true;
1355         else
1356                 *is_roaming = false;
1357
1358         return CONNECTION_ERROR_NONE;
1359 }
1360
1361 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
1362 {
1363         if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
1364                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1365                 return CONNECTION_ERROR_INVALID_PARAMETER;
1366         }
1367
1368         net_profile_info_t *profile_info = profile;
1369
1370         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1371                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1372                 return CONNECTION_ERROR_INVALID_PARAMETER;
1373         }
1374
1375         if (profile_info->ProfileInfo.Pdp.Hidden)
1376                 *is_hidden = true;
1377         else
1378                 *is_hidden = false;
1379
1380         return CONNECTION_ERROR_NONE;
1381 }
1382
1383 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
1384 {
1385         if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
1386                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1387                 return CONNECTION_ERROR_INVALID_PARAMETER;
1388         }
1389
1390         net_profile_info_t *profile_info = profile;
1391
1392         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1393                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1394                 return CONNECTION_ERROR_INVALID_PARAMETER;
1395         }
1396
1397         if (profile_info->ProfileInfo.Pdp.Editable)
1398                 *is_editable = true;
1399         else
1400                 *is_editable = false;
1401
1402         return CONNECTION_ERROR_NONE;
1403 }
1404
1405 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
1406 {
1407         if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
1408                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1409                 return CONNECTION_ERROR_INVALID_PARAMETER;
1410         }
1411
1412         net_profile_info_t *profile_info = profile;
1413
1414         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1415                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1416                 return CONNECTION_ERROR_INVALID_PARAMETER;
1417         }
1418
1419         if (profile_info->ProfileInfo.Pdp.DefaultConn)
1420                 *is_default = true;
1421         else
1422                 *is_default = false;
1423
1424         return CONNECTION_ERROR_NONE;
1425 }
1426
1427 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
1428                 connection_cellular_service_type_e service_type)
1429 {
1430         if (!(_connection_libnet_check_profile_validity(profile))) {
1431                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1432                 return CONNECTION_ERROR_INVALID_PARAMETER;
1433         }
1434
1435         net_profile_info_t *profile_info = profile;
1436
1437         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1438                 return CONNECTION_ERROR_INVALID_PARAMETER;
1439
1440         switch (service_type) {
1441         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1442                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1443                 break;
1444         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1445                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1446                 break;
1447         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1448                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1449                 break;
1450         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1451                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1452                 break;
1453         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1454                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1455                 break;
1456         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1457                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1458                 break;
1459         case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1460         default:
1461                 return CONNECTION_ERROR_INVALID_PARAMETER;
1462         }
1463
1464         return CONNECTION_ERROR_NONE;
1465 }
1466
1467 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1468 {
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;
1472         }
1473
1474         net_profile_info_t *profile_info = profile;
1475
1476         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1477                 return CONNECTION_ERROR_INVALID_PARAMETER;
1478
1479         g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1480
1481         return CONNECTION_ERROR_NONE;
1482 }
1483
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)
1486 {
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;
1491         }
1492
1493         net_profile_info_t *profile_info = profile;
1494
1495         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1496                 return CONNECTION_ERROR_INVALID_PARAMETER;
1497
1498         switch (type) {
1499         case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1500                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1501                 break;
1502         case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1503                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1504                 break;
1505         case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1506                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1507                 break;
1508         default:
1509                 return CONNECTION_ERROR_INVALID_PARAMETER;
1510         }
1511
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);
1514
1515         return CONNECTION_ERROR_NONE;
1516 }
1517
1518 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1519 {
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;
1523         }
1524
1525         net_profile_info_t *profile_info = profile;
1526
1527         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1528                 return CONNECTION_ERROR_INVALID_PARAMETER;
1529
1530         g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1531
1532         return CONNECTION_ERROR_NONE;
1533 }