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 <glib.h>
  20 #include <vconf/vconf.h>
  21 #include "net_connection_private.h"
  22
  23 #define HTTP_PROXY "http_proxy"
  24
  25 static net_dev_info_t* __profile_get_net_info(net_profile_info_t *profile_info)
  26 {
  27         switch (profile_info->profile_type) {
  28         case NET_DEVICE_CELLULAR:
  29                 return &profile_info->ProfileInfo.Pdp.net_info;
  30         case NET_DEVICE_WIFI:
  31                 return &profile_info->ProfileInfo.Wlan.net_info;
  32         case NET_DEVICE_ETHERNET:
  33                 return &profile_info->ProfileInfo.Ethernet.net_info;
  34         case NET_DEVICE_BLUETOOTH:
  35                 return &profile_info->ProfileInfo.Bluetooth.net_info;
  36         case NET_DEVICE_DEFAULT:
  37         case NET_DEVICE_USB:
  38         case NET_DEVICE_UNKNOWN:
  39         case NET_DEVICE_MAX:
  40         default:
  41                 return NULL;
  42         }
  43 }
  44
  45 static char* __profile_convert_ip_to_string(net_addr_t *ip_addr)
  46 {
  47         unsigned char *ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
  48
  49         char *ipstr = g_try_malloc0(16);
  50         if (ipstr == NULL)
  51                 return NULL;
  52
  53         snprintf(ipstr, 16, "%d.%d.%d.%d", ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3]);
  54
  55         return ipstr;
  56 }
  57
  58 static void __profile_init_cellular_profile(net_profile_info_t *profile_info, const char *keyword)
  59 {
  60         profile_info->profile_type = NET_DEVICE_CELLULAR;
  61         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
  62         profile_info->ProfileInfo.Pdp.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
  63         profile_info->ProfileInfo.Pdp.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
  64         g_strlcpy(profile_info->ProfileInfo.Pdp.Keyword, keyword, NET_PDP_APN_LEN_MAX);
  65 }
  66
  67 static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
  68 {
  69         profile_info->profile_type = NET_DEVICE_WIFI;
  70         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
  71         profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
  72         profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
  73         profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
  74         profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
  75         profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
  76 }
  77
  78 static const char* __profile_get_ethernet_proxy(void)
  79 {
  80         char *proxy;
  81
  82         proxy = getenv(HTTP_PROXY);
  83
  84         if(proxy == NULL) {
  85                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
  86                 return NULL;
  87         }
  88
  89         CONNECTION_LOG(CONNECTION_INFO, "Get system proxy: %s", proxy);
  90         return proxy;
  91 }
  92
  93 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
  94 {
  95         switch (svc_type) {
  96         case NET_SERVICE_INTERNET:
  97                 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
  98         case NET_SERVICE_MMS:
  99                 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
 100         case NET_SERVICE_PREPAID_INTERNET:
 101                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
 102         case NET_SERVICE_PREPAID_MMS:
 103                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
 104         case NET_SERVICE_TETHERING:
 105                 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
 106         case NET_SERVICE_APPLICATION:
 107                 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
 108         default:
 109                 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
 110         }
 111 }
 112
 113 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
 114 {
 115         connection_profile_state_e cp_state;
 116
 117         switch (state) {
 118         case NET_STATE_TYPE_ONLINE:
 119         case NET_STATE_TYPE_READY:
 120                 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
 121                 break;
 122         case NET_STATE_TYPE_IDLE:
 123         case NET_STATE_TYPE_FAILURE:
 124         case NET_STATE_TYPE_DISCONNECT:
 125                 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
 126                 break;
 127         case NET_STATE_TYPE_ASSOCIATION:
 128                 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
 129                 break;
 130         case NET_STATE_TYPE_CONFIGURATION:
 131                 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
 132                 break;
 133         default:
 134                 cp_state = -1;
 135         }
 136
 137         return cp_state;
 138 }
 139
 140 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
 141 {
 142         switch (svc_type) {
 143         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
 144                 return NET_SERVICE_INTERNET;
 145         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
 146                 return NET_SERVICE_MMS;
 147         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
 148                 return NET_SERVICE_PREPAID_INTERNET;
 149         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
 150                 return NET_SERVICE_PREPAID_MMS;
 151         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
 152                 return NET_SERVICE_TETHERING;
 153         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
 154                 return NET_SERVICE_APPLICATION;
 155         default:
 156                 return NET_SERVICE_UNKNOWN;
 157         }
 158 }
 159
 160 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
 161 {
 162         net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
 163
 164         switch (state) {
 165         case CONNECTION_PROFILE_STATE_CONNECTED:
 166                 libnet_state = NET_STATE_TYPE_ONLINE;
 167                 break;
 168         case CONNECTION_PROFILE_STATE_DISCONNECTED:
 169                 libnet_state = NET_STATE_TYPE_IDLE;
 170                 break;
 171         case CONNECTION_PROFILE_STATE_ASSOCIATION:
 172                 libnet_state = NET_STATE_TYPE_ASSOCIATION;
 173                 break;
 174         case CONNECTION_PROFILE_STATE_CONFIGURATION:
 175                 libnet_state = NET_STATE_TYPE_CONFIGURATION;
 176                 break;
 177         }
 178
 179         return libnet_state;
 180 }
 181
 182
 183 /* Connection profile module *********************************************************************/
 184
 185 int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
 186 {
 187         if ((type != CONNECTION_PROFILE_TYPE_CELLULAR &&
 188              type != CONNECTION_PROFILE_TYPE_WIFI) || profile == NULL) {
 189                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 190                 return CONNECTION_ERROR_INVALID_PARAMETER;
 191         }
 192
 193         net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
 194         if (profile_info == NULL)
 195                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 196
 197         switch (type) {
 198         case CONNECTION_PROFILE_TYPE_CELLULAR:
 199                 if (keyword == NULL) {
 200                         CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 201                         return CONNECTION_ERROR_INVALID_PARAMETER;
 202                 }
 203                 __profile_init_cellular_profile(profile_info, keyword);
 204                 break;
 205         case CONNECTION_PROFILE_TYPE_WIFI:
 206                 __profile_init_wifi_profile(profile_info);
 207                 break;
 208         default:
 209                 break;
 210         }
 211
 212         *profile = (connection_profile_h)profile_info;
 213         _connection_libnet_add_to_profile_list(*profile);
 214
 215         return CONNECTION_ERROR_NONE;
 216 }
 217
 218 int connection_profile_destroy(connection_profile_h profile)
 219 {
 220         if (!(_connection_libnet_check_profile_validity(profile))) {
 221                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 222                 return CONNECTION_ERROR_INVALID_PARAMETER;
 223         }
 224
 225         _connection_libnet_remove_from_profile_list(profile);
 226
 227         return CONNECTION_ERROR_NONE;
 228 }
 229
 230 int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
 231 {
 232         if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
 233                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 234                 return CONNECTION_ERROR_INVALID_PARAMETER;
 235         }
 236
 237         *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
 238         if (*cloned_profile == NULL)
 239                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 240
 241         memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
 242         _connection_libnet_add_to_profile_list(*cloned_profile);
 243
 244         return CONNECTION_ERROR_NONE;
 245 }
 246
 247 int connection_profile_get_id(connection_profile_h profile, char** profile_id)
 248 {
 249         if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
 250                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 251                 return CONNECTION_ERROR_INVALID_PARAMETER;
 252         }
 253
 254         net_profile_info_t *profile_info = profile;
 255
 256         char *prof_id = strrchr(profile_info->ProfileName, '/');
 257         if (prof_id == NULL)
 258                 return CONNECTION_ERROR_INVALID_PARAMETER;
 259
 260         prof_id++;
 261         *profile_id = g_strdup(prof_id);
 262
 263         if (*profile_id == NULL)
 264                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 265
 266         return CONNECTION_ERROR_NONE;
 267 }
 268
 269 int connection_profile_get_name(connection_profile_h profile, char** profile_name)
 270 {
 271         if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
 272                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 273                 return CONNECTION_ERROR_INVALID_PARAMETER;
 274         }
 275
 276         net_profile_info_t *profile_info = profile;
 277
 278         switch (profile_info->profile_type) {
 279         case NET_DEVICE_CELLULAR:
 280                 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
 281                 break;
 282         case NET_DEVICE_WIFI:
 283                 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
 284                 break;
 285         case NET_DEVICE_ETHERNET:
 286                 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName);
 287                 break;
 288         case NET_DEVICE_BLUETOOTH: {
 289                 char *bt_name = strrchr(profile_info->ProfileName, '/');
 290                 if (bt_name == NULL)
 291                         return CONNECTION_ERROR_INVALID_PARAMETER;
 292
 293                 bt_name++;
 294                 *profile_name = g_strdup(bt_name);
 295         } break;
 296         default:
 297                 return CONNECTION_ERROR_INVALID_PARAMETER;
 298         }
 299
 300         if (*profile_name == NULL)
 301                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 302
 303         return CONNECTION_ERROR_NONE;
 304 }
 305
 306 int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e* type)
 307 {
 308         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 309                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 310                 return CONNECTION_ERROR_INVALID_PARAMETER;
 311         }
 312
 313         net_profile_info_t *profile_info = profile;
 314
 315         switch (profile_info->profile_type) {
 316         case NET_DEVICE_CELLULAR:
 317                 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
 318                 break;
 319         case NET_DEVICE_WIFI:
 320                 *type = CONNECTION_PROFILE_TYPE_WIFI;
 321                 break;
 322         case NET_DEVICE_ETHERNET:
 323                 *type = CONNECTION_PROFILE_TYPE_ETHERNET;
 324                 break;
 325         case NET_DEVICE_BLUETOOTH:
 326                 *type = CONNECTION_PROFILE_TYPE_BT;
 327                 break;
 328         default:
 329                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type\n");
 330                 return CONNECTION_ERROR_OPERATION_FAILED;
 331         }
 332
 333         return CONNECTION_ERROR_NONE;
 334 }
 335
 336 int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
 337 {
 338         if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
 339                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 340                 return CONNECTION_ERROR_INVALID_PARAMETER;
 341         }
 342
 343         net_profile_info_t *profile_info = profile;
 344         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 345         if (net_info == NULL)
 346                 return CONNECTION_ERROR_INVALID_PARAMETER;
 347
 348         *interface_name = g_strdup(net_info->DevName);
 349         if (*interface_name == NULL)
 350                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 351
 352         return CONNECTION_ERROR_NONE;
 353 }
 354
 355 int connection_profile_refresh(connection_profile_h profile)
 356 {
 357         if (!(_connection_libnet_check_profile_validity(profile))) {
 358                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 359                 return CONNECTION_ERROR_INVALID_PARAMETER;
 360         }
 361
 362         net_profile_info_t profile_info_local;
 363         net_profile_info_t *profile_info = profile;
 364
 365         if (net_get_profile_info(profile_info->ProfileName, &profile_info_local) != NET_ERR_NONE) {
 366                 CONNECTION_LOG(CONNECTION_ERROR, "Error!!! net_get_profile_info() failed\n");
 367                 return CONNECTION_ERROR_OPERATION_FAILED;
 368         }
 369
 370         memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
 371
 372         return CONNECTION_ERROR_NONE;
 373 }
 374
 375 int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
 376 {
 377         if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
 378                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 379                 return CONNECTION_ERROR_INVALID_PARAMETER;
 380         }
 381
 382         net_profile_info_t *profile_info = profile;
 383         *state = _profile_convert_to_cp_state(profile_info->ProfileState);
 384         if (*state < 0)
 385                 return CONNECTION_ERROR_OPERATION_FAILED;
 386
 387         return CONNECTION_ERROR_NONE;
 388 }
 389
 390 int connection_profile_get_ip_config_type(connection_profile_h profile,
 391                 connection_address_family_e address_family, connection_ip_config_type_e* type)
 392 {
 393         if (!(_connection_libnet_check_profile_validity(profile)) ||
 394             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 395              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 396             type == NULL) {
 397                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 398                 return CONNECTION_ERROR_INVALID_PARAMETER;
 399         }
 400
 401         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 402                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 403
 404         net_profile_info_t *profile_info = profile;
 405         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 406         if (net_info == NULL)
 407                 return CONNECTION_ERROR_OPERATION_FAILED;
 408
 409         switch (net_info->IpConfigType) {
 410         case NET_IP_CONFIG_TYPE_STATIC:
 411                 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 412                 break;
 413         case NET_IP_CONFIG_TYPE_DYNAMIC:
 414                 *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
 415                 break;
 416         case NET_IP_CONFIG_TYPE_AUTO_IP:
 417                 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 418                 break;
 419         case NET_IP_CONFIG_TYPE_FIXED:
 420                 *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
 421                 break;
 422         case NET_IP_CONFIG_TYPE_OFF:
 423                 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 424                 break;
 425         default:
 426                 return CONNECTION_ERROR_OPERATION_FAILED;
 427         }
 428
 429         return CONNECTION_ERROR_NONE;
 430 }
 431
 432 int connection_profile_get_ip_address(connection_profile_h profile,
 433                 connection_address_family_e address_family, char** ip_address)
 434 {
 435         if (!(_connection_libnet_check_profile_validity(profile)) ||
 436             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 437              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 438             ip_address == NULL) {
 439                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 440                 return CONNECTION_ERROR_INVALID_PARAMETER;
 441         }
 442
 443         net_profile_info_t *profile_info = profile;
 444         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 445         if (net_info == NULL)
 446                 return CONNECTION_ERROR_OPERATION_FAILED;
 447
 448         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 449                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 450
 451         *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr);
 452         if (*ip_address == NULL)
 453                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 454
 455         return CONNECTION_ERROR_NONE;
 456 }
 457
 458 int connection_profile_get_subnet_mask(connection_profile_h profile,
 459                 connection_address_family_e address_family, char** subnet_mask)
 460 {
 461         if (!(_connection_libnet_check_profile_validity(profile)) ||
 462             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 463              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 464             subnet_mask == NULL) {
 465                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 466                 return CONNECTION_ERROR_INVALID_PARAMETER;
 467         }
 468
 469         net_profile_info_t *profile_info = profile;
 470         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 471         if (net_info == NULL)
 472                 return CONNECTION_ERROR_OPERATION_FAILED;
 473
 474         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 475                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 476
 477         *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask);
 478         if (*subnet_mask == NULL)
 479                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 480
 481         return CONNECTION_ERROR_NONE;
 482 }
 483
 484 int connection_profile_get_gateway_address(connection_profile_h profile,
 485                 connection_address_family_e address_family, char** gateway_address)
 486 {
 487         if (!(_connection_libnet_check_profile_validity(profile)) ||
 488             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 489              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 490             gateway_address == NULL) {
 491                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 492                 return CONNECTION_ERROR_INVALID_PARAMETER;
 493         }
 494
 495         net_profile_info_t *profile_info = profile;
 496         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 497         if (net_info == NULL)
 498                 return CONNECTION_ERROR_OPERATION_FAILED;
 499
 500         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 501                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 502
 503         *gateway_address = __profile_convert_ip_to_string(&net_info->GatewayAddr);
 504         if (*gateway_address == NULL)
 505                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 506
 507         return CONNECTION_ERROR_NONE;
 508 }
 509
 510 int connection_profile_get_dns_address(connection_profile_h profile, int order,
 511                 connection_address_family_e address_family, char** dns_address)
 512 {
 513         if (!(_connection_libnet_check_profile_validity(profile)) ||
 514             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 515              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 516             dns_address == NULL ||
 517             order <= 0 ||
 518             order > NET_DNS_ADDR_MAX) {
 519                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 520                 return CONNECTION_ERROR_INVALID_PARAMETER;
 521         }
 522
 523         net_profile_info_t *profile_info = profile;
 524         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 525         if (net_info == NULL)
 526                 return CONNECTION_ERROR_OPERATION_FAILED;
 527
 528         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 529                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 530
 531         *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1]);
 532         if (*dns_address == NULL)
 533                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 534
 535         return CONNECTION_ERROR_NONE;
 536 }
 537
 538 int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e* type)
 539 {
 540         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 541                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 542                 return CONNECTION_ERROR_INVALID_PARAMETER;
 543         }
 544
 545         const char *proxy;
 546         net_profile_info_t *profile_info = profile;
 547         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 548         if (net_info == NULL)
 549                 return CONNECTION_ERROR_OPERATION_FAILED;
 550
 551         if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
 552                 proxy = __profile_get_ethernet_proxy();
 553                 if (proxy == NULL)
 554                         *type = CONNECTION_PROXY_TYPE_DIRECT;
 555                 else
 556                         *type = CONNECTION_PROXY_TYPE_MANUAL;
 557
 558                 return CONNECTION_ERROR_NONE;
 559         }
 560
 561         switch (net_info->ProxyMethod) {
 562         case NET_PROXY_TYPE_DIRECT:
 563                 *type = CONNECTION_PROXY_TYPE_DIRECT;
 564                 break;
 565         case NET_PROXY_TYPE_AUTO:
 566                 *type = CONNECTION_PROXY_TYPE_AUTO;
 567                 break;
 568         case NET_PROXY_TYPE_MANUAL:
 569                 *type = CONNECTION_PROXY_TYPE_MANUAL;
 570                 break;
 571         case NET_PROXY_TYPE_UNKNOWN:
 572         default:
 573                 return CONNECTION_ERROR_OPERATION_FAILED;
 574         }
 575
 576         return CONNECTION_ERROR_NONE;
 577 }
 578
 579 int connection_profile_get_proxy_address(connection_profile_h profile,
 580                 connection_address_family_e address_family, char** proxy_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              proxy_address == NULL) {
 586                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 587                 return CONNECTION_ERROR_INVALID_PARAMETER;
 588         }
 589
 590         const char *proxy;
 591         net_profile_info_t *profile_info = profile;
 592         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 593         if (net_info == NULL)
 594                 return CONNECTION_ERROR_OPERATION_FAILED;
 595
 596         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 597                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 598
 599         if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
 600                 proxy = __profile_get_ethernet_proxy();
 601                 if (proxy == NULL)
 602                         return CONNECTION_ERROR_OPERATION_FAILED;
 603
 604                 *proxy_address = g_strdup(proxy);
 605         } else
 606                 *proxy_address = g_strdup(net_info->ProxyAddr);
 607
 608         if (*proxy_address == NULL)
 609                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 610
 611         return CONNECTION_ERROR_NONE;
 612 }
 613
 614 int connection_profile_set_ip_config_type(connection_profile_h profile,
 615                 connection_address_family_e address_family, connection_ip_config_type_e type)
 616 {
 617         if (!(_connection_libnet_check_profile_validity(profile)) ||
 618             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 619              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 620                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 621                 return CONNECTION_ERROR_INVALID_PARAMETER;
 622         }
 623
 624         net_profile_info_t *profile_info = profile;
 625         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 626         if (net_info == NULL)
 627                 return CONNECTION_ERROR_OPERATION_FAILED;
 628
 629         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 630                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 631
 632         switch (type) {
 633         case CONNECTION_IP_CONFIG_TYPE_STATIC:
 634                 net_info->IpConfigType = NET_IP_CONFIG_TYPE_STATIC;
 635                 net_info->IpAddr.Data.Ipv4.s_addr = 0;
 636                 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
 637                 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
 638                 break;
 639         case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
 640                 net_info->IpConfigType = NET_IP_CONFIG_TYPE_DYNAMIC;
 641                 break;
 642         case CONNECTION_IP_CONFIG_TYPE_AUTO:
 643                 net_info->IpConfigType = NET_IP_CONFIG_TYPE_AUTO_IP;
 644                 break;
 645         case CONNECTION_IP_CONFIG_TYPE_FIXED:
 646                 net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
 647                 break;
 648         case CONNECTION_IP_CONFIG_TYPE_NONE:
 649                 net_info->IpConfigType = NET_IP_CONFIG_TYPE_OFF;
 650                 break;
 651         default:
 652                 return CONNECTION_ERROR_INVALID_PARAMETER;
 653         }
 654
 655         return CONNECTION_ERROR_NONE;
 656 }
 657
 658 int connection_profile_set_ip_address(connection_profile_h profile,
 659                 connection_address_family_e address_family, const char* ip_address)
 660 {
 661         if (!(_connection_libnet_check_profile_validity(profile)) ||
 662             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 663              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 664                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 665                 return CONNECTION_ERROR_INVALID_PARAMETER;
 666         }
 667
 668         net_profile_info_t *profile_info = profile;
 669         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 670         if (net_info == NULL)
 671                 return CONNECTION_ERROR_OPERATION_FAILED;
 672
 673         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 674                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 675
 676         if (ip_address == NULL)
 677                 net_info->IpAddr.Data.Ipv4.s_addr = 0;
 678         else if (inet_aton(ip_address, &(net_info->IpAddr.Data.Ipv4)) == 0)
 679                 return CONNECTION_ERROR_INVALID_PARAMETER;
 680
 681         return CONNECTION_ERROR_NONE;
 682 }
 683
 684 int connection_profile_set_subnet_mask(connection_profile_h profile,
 685                 connection_address_family_e address_family, const char* subnet_mask)
 686 {
 687         if (!(_connection_libnet_check_profile_validity(profile)) ||
 688             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 689              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 690                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 691                 return CONNECTION_ERROR_INVALID_PARAMETER;
 692         }
 693
 694         net_profile_info_t *profile_info = profile;
 695         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 696         if (net_info == NULL)
 697                 return CONNECTION_ERROR_OPERATION_FAILED;
 698
 699         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 700                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 701
 702         if (subnet_mask == NULL)
 703                 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
 704         else if (inet_aton(subnet_mask, &(net_info->SubnetMask.Data.Ipv4)) == 0)
 705                 return CONNECTION_ERROR_INVALID_PARAMETER;
 706
 707         return CONNECTION_ERROR_NONE;
 708 }
 709
 710 int connection_profile_set_gateway_address(connection_profile_h profile,
 711                 connection_address_family_e address_family, const char* gateway_address)
 712 {
 713         if (!(_connection_libnet_check_profile_validity(profile)) ||
 714             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 715              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 716                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 717                 return CONNECTION_ERROR_INVALID_PARAMETER;
 718         }
 719
 720         net_profile_info_t *profile_info = profile;
 721         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 722         if (net_info == NULL)
 723                 return CONNECTION_ERROR_OPERATION_FAILED;
 724
 725         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 726                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 727
 728         if (gateway_address == NULL)
 729                 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
 730         else if (inet_aton(gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) == 0)
 731                 return CONNECTION_ERROR_INVALID_PARAMETER;
 732
 733         return CONNECTION_ERROR_NONE;
 734 }
 735
 736 int connection_profile_set_dns_address(connection_profile_h profile, int order,
 737                 connection_address_family_e address_family, const char* dns_address)
 738 {
 739         if (!(_connection_libnet_check_profile_validity(profile)) ||
 740             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 741              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 742             order <= 0 ||
 743             order > NET_DNS_ADDR_MAX) {
 744                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 745                 return CONNECTION_ERROR_INVALID_PARAMETER;
 746         }
 747
 748         net_profile_info_t *profile_info = profile;
 749         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 750         if (net_info == NULL)
 751                 return CONNECTION_ERROR_OPERATION_FAILED;
 752
 753         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 754                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 755
 756         if (dns_address == NULL)
 757                 net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
 758         else if (inet_aton(dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) == 0)
 759                 return CONNECTION_ERROR_INVALID_PARAMETER;
 760
 761         return CONNECTION_ERROR_NONE;
 762 }
 763
 764 int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
 765 {
 766         if (!(_connection_libnet_check_profile_validity(profile))) {
 767                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 768                 return CONNECTION_ERROR_INVALID_PARAMETER;
 769         }
 770
 771         net_profile_info_t *profile_info = profile;
 772         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 773         if (net_info == NULL)
 774                 return CONNECTION_ERROR_OPERATION_FAILED;
 775
 776         switch (type) {
 777         case CONNECTION_PROXY_TYPE_DIRECT:
 778                 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
 779                 break;
 780         case CONNECTION_PROXY_TYPE_AUTO:
 781                 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
 782                 break;
 783         case CONNECTION_PROXY_TYPE_MANUAL:
 784                 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
 785                 break;
 786         default:
 787                 return CONNECTION_ERROR_INVALID_PARAMETER;
 788         }
 789
 790         return CONNECTION_ERROR_NONE;
 791 }
 792
 793 int connection_profile_set_proxy_address(connection_profile_h profile,
 794                 connection_address_family_e address_family, const char* proxy_address)
 795 {
 796         if (!(_connection_libnet_check_profile_validity(profile)) ||
 797             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 798              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 799                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 800                 return CONNECTION_ERROR_INVALID_PARAMETER;
 801         }
 802
 803         net_profile_info_t *profile_info = profile;
 804         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 805         if (net_info == NULL)
 806                 return CONNECTION_ERROR_OPERATION_FAILED;
 807
 808         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 809                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 810
 811         if (proxy_address == NULL)
 812                 net_info->ProxyAddr[0] = '\0';
 813         else
 814                 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
 815
 816         return CONNECTION_ERROR_NONE;
 817 }
 818
 819 int connection_profile_set_state_changed_cb(connection_profile_h profile,
 820                 connection_profile_state_changed_cb callback, void* user_data)
 821 {
 822         if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
 823                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 824                 return CONNECTION_ERROR_INVALID_PARAMETER;
 825         }
 826
 827         if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
 828                 return CONNECTION_ERROR_NONE;
 829
 830         return CONNECTION_ERROR_OPERATION_FAILED;
 831 }
 832
 833 int connection_profile_unset_state_changed_cb(connection_profile_h profile)
 834 {
 835         if (!(_connection_libnet_check_profile_cb_validity(profile))) {
 836                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 837                 return CONNECTION_ERROR_INVALID_PARAMETER;
 838         }
 839
 840         _connection_libnet_remove_from_profile_cb_list(profile);
 841
 842         return CONNECTION_ERROR_NONE;
 843 }
 844
 845
 846 /* Wi-Fi profile module **************************************************************************/
 847
 848 int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
 849 {
 850         if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
 851                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 852                 return CONNECTION_ERROR_INVALID_PARAMETER;
 853         }
 854
 855         net_profile_info_t *profile_info = profile;
 856
 857         if (profile_info->profile_type != NET_DEVICE_WIFI)
 858                 return CONNECTION_ERROR_INVALID_PARAMETER;
 859
 860         *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
 861         if (*essid == NULL)
 862                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 863
 864         return CONNECTION_ERROR_NONE;
 865 }
 866
 867 int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
 868 {
 869         if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
 870                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 871                 return CONNECTION_ERROR_INVALID_PARAMETER;
 872         }
 873
 874         net_profile_info_t *profile_info = profile;
 875
 876         if (profile_info->profile_type != NET_DEVICE_WIFI)
 877                 return CONNECTION_ERROR_INVALID_PARAMETER;
 878
 879         *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
 880         if (*bssid == NULL)
 881                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 882
 883         return CONNECTION_ERROR_NONE;
 884 }
 885
 886 int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
 887 {
 888         if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
 889                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 890                 return CONNECTION_ERROR_INVALID_PARAMETER;
 891         }
 892
 893         net_profile_info_t *profile_info = profile;
 894
 895         if (profile_info->profile_type != NET_DEVICE_WIFI)
 896                 return CONNECTION_ERROR_INVALID_PARAMETER;
 897
 898         *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
 899
 900         return CONNECTION_ERROR_NONE;
 901 }
 902
 903 int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
 904 {
 905         if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
 906                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 907                 return CONNECTION_ERROR_INVALID_PARAMETER;
 908         }
 909
 910         net_profile_info_t *profile_info = profile;
 911
 912         if (profile_info->profile_type != NET_DEVICE_WIFI)
 913                 return CONNECTION_ERROR_INVALID_PARAMETER;
 914
 915         *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
 916
 917         return CONNECTION_ERROR_NONE;
 918 }
 919
 920 int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
 921 {
 922         if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
 923                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 924                 return CONNECTION_ERROR_INVALID_PARAMETER;
 925         }
 926
 927         net_profile_info_t *profile_info = profile;
 928
 929         if (profile_info->profile_type != NET_DEVICE_WIFI)
 930                 return CONNECTION_ERROR_INVALID_PARAMETER;
 931
 932         *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate;
 933
 934         return CONNECTION_ERROR_NONE;
 935 }
 936
 937 int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e* type)
 938 {
 939         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 940                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 941                 return CONNECTION_ERROR_INVALID_PARAMETER;
 942         }
 943
 944         net_profile_info_t *profile_info = profile;
 945
 946         if (profile_info->profile_type != NET_DEVICE_WIFI)
 947                 return CONNECTION_ERROR_INVALID_PARAMETER;
 948
 949         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
 950         case WLAN_SEC_MODE_NONE:
 951                 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
 952                 break;
 953         case WLAN_SEC_MODE_WEP:
 954                 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
 955                 break;
 956         case WLAN_SEC_MODE_IEEE8021X:
 957                 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
 958                 break;
 959         case WLAN_SEC_MODE_WPA_PSK:
 960                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
 961                 break;
 962         case WLAN_SEC_MODE_WPA2_PSK:
 963                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
 964                 break;
 965         default:
 966                 return CONNECTION_ERROR_OPERATION_FAILED;
 967         }
 968
 969         return CONNECTION_ERROR_NONE;
 970 }
 971
 972 int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e* type)
 973 {
 974         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 975                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 976                 return CONNECTION_ERROR_INVALID_PARAMETER;
 977         }
 978
 979         net_profile_info_t *profile_info = profile;
 980
 981         if (profile_info->profile_type != NET_DEVICE_WIFI)
 982                 return CONNECTION_ERROR_INVALID_PARAMETER;
 983
 984         switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
 985         case WLAN_ENC_MODE_NONE:
 986                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
 987                 break;
 988         case WLAN_ENC_MODE_WEP:
 989                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
 990                 break;
 991         case WLAN_ENC_MODE_TKIP:
 992                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
 993                 break;
 994         case WLAN_ENC_MODE_AES:
 995                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
 996                 break;
 997         case WLAN_ENC_MODE_TKIP_AES_MIXED:
 998                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
 999                 break;
1000         default:
1001                 return CONNECTION_ERROR_OPERATION_FAILED;
1002         }
1003
1004         return CONNECTION_ERROR_NONE;
1005 }
1006
1007 int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1008 {
1009         if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1010                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1011                 return CONNECTION_ERROR_INVALID_PARAMETER;
1012         }
1013
1014         net_profile_info_t *profile_info = profile;
1015
1016         if (profile_info->profile_type != NET_DEVICE_WIFI)
1017                 return CONNECTION_ERROR_INVALID_PARAMETER;
1018
1019         if (profile_info->Favourite) {
1020                 *required = false;
1021                 return CONNECTION_ERROR_NONE;
1022         }
1023
1024         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1025         case WLAN_SEC_MODE_NONE:
1026                 *required = false;
1027                 break;
1028         case WLAN_SEC_MODE_WEP:
1029         case WLAN_SEC_MODE_IEEE8021X:
1030         case WLAN_SEC_MODE_WPA_PSK:
1031         case WLAN_SEC_MODE_WPA2_PSK:
1032                 *required = true;
1033                 break;
1034         default:
1035                 return CONNECTION_ERROR_OPERATION_FAILED;
1036         }
1037
1038         return CONNECTION_ERROR_NONE;
1039 }
1040
1041 int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1042 {
1043         if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1044                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1045                 return CONNECTION_ERROR_INVALID_PARAMETER;
1046         }
1047
1048         net_profile_info_t *profile_info = profile;
1049
1050         if (profile_info->profile_type != NET_DEVICE_WIFI)
1051                 return CONNECTION_ERROR_INVALID_PARAMETER;
1052
1053         g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1054                                                 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1055
1056         return CONNECTION_ERROR_NONE;
1057 }
1058
1059 int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1060 {
1061         if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1062                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1063                 return CONNECTION_ERROR_INVALID_PARAMETER;
1064         }
1065
1066         net_profile_info_t *profile_info = profile;
1067
1068         if (profile_info->profile_type != NET_DEVICE_WIFI)
1069                 return CONNECTION_ERROR_INVALID_PARAMETER;
1070
1071         if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1072                 *supported = true;
1073         else
1074                 *supported = false;
1075
1076         return CONNECTION_ERROR_NONE;
1077 }
1078
1079
1080 /* Cellular profile module ***********************************************************************/
1081
1082 int connection_profile_get_cellular_network_type(connection_profile_h profile, connection_cellular_network_type_e* type)
1083 {
1084         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1085                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1086                 return CONNECTION_ERROR_INVALID_PARAMETER;
1087         }
1088
1089         int network_type;
1090         net_profile_info_t *profile_info = profile;
1091
1092         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1093                 return CONNECTION_ERROR_INVALID_PARAMETER;
1094
1095         if (vconf_get_int(VCONFKEY_TELEPHONY_SVC_ACT, &network_type)) {
1096                 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed\n");
1097                 return CONNECTION_ERROR_OPERATION_FAILED;
1098         }
1099
1100         CONNECTION_LOG(CONNECTION_INFO, "Cellular network type = %d\n", network_type);
1101
1102         switch (network_type) {
1103         case VCONFKEY_TELEPHONY_SVC_ACT_NONE:
1104                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UNKNOWN;
1105                 break;
1106         case VCONFKEY_TELEPHONY_SVC_ACT_GPRS:
1107                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_GPRS;
1108                 break;
1109         case VCONFKEY_TELEPHONY_SVC_ACT_EGPRS:
1110                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_EDGE;
1111                 break;
1112         case VCONFKEY_TELEPHONY_SVC_ACT_UMTS:
1113                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UMTS;
1114                 break;
1115         default:
1116                 return CONNECTION_ERROR_OPERATION_FAILED;
1117         }
1118
1119         return CONNECTION_ERROR_NONE;
1120 }
1121
1122 int connection_profile_get_cellular_service_type(connection_profile_h profile,
1123                                                 connection_cellular_service_type_e* type)
1124 {
1125         if (!(_connection_libnet_check_profile_validity(profile)) || type == 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_CELLULAR) {
1133                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type Passed\n");
1134                 return CONNECTION_ERROR_INVALID_PARAMETER;
1135         }
1136
1137         *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1138
1139         if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1140                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed\n");
1141                 return CONNECTION_ERROR_OPERATION_FAILED;
1142         }
1143
1144         return CONNECTION_ERROR_NONE;
1145 }
1146
1147 int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1148 {
1149         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1150                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1151                 return CONNECTION_ERROR_INVALID_PARAMETER;
1152         }
1153
1154         net_profile_info_t *profile_info = profile;
1155
1156         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1157                 return CONNECTION_ERROR_INVALID_PARAMETER;
1158
1159         *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1160         if (*apn == NULL)
1161                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1162
1163         return CONNECTION_ERROR_NONE;
1164 }
1165
1166 int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1167                 connection_cellular_auth_type_e* type, char** user_name, char** password)
1168 {
1169         if (!(_connection_libnet_check_profile_validity(profile)) ||
1170             type == NULL || user_name == NULL || password == NULL) {
1171                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1172                 return CONNECTION_ERROR_INVALID_PARAMETER;
1173         }
1174
1175         net_profile_info_t *profile_info = profile;
1176
1177         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1178                 return CONNECTION_ERROR_INVALID_PARAMETER;
1179
1180         switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1181         case NET_PDP_AUTH_NONE:
1182                 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1183                 break;
1184         case NET_PDP_AUTH_PAP:
1185                 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1186                 break;
1187         case NET_PDP_AUTH_CHAP:
1188                 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1189                 break;
1190         default:
1191                 return CONNECTION_ERROR_OPERATION_FAILED;
1192         }
1193
1194         *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1195         if (*user_name == NULL)
1196                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1197
1198         *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1199         if (*password == NULL) {
1200                 g_free(*user_name);
1201                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1202         }
1203
1204         return CONNECTION_ERROR_NONE;
1205 }
1206
1207 int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1208 {
1209         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1210                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1211                 return CONNECTION_ERROR_INVALID_PARAMETER;
1212         }
1213
1214         net_profile_info_t *profile_info = profile;
1215
1216         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1217                 return CONNECTION_ERROR_INVALID_PARAMETER;
1218
1219         *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1220         if (*home_url == NULL)
1221                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1222
1223         return CONNECTION_ERROR_NONE;
1224 }
1225
1226 int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1227 {
1228         if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1229                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1230                 return CONNECTION_ERROR_INVALID_PARAMETER;
1231         }
1232
1233         net_profile_info_t *profile_info = profile;
1234
1235         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1236                 return CONNECTION_ERROR_INVALID_PARAMETER;
1237
1238         if (profile_info->ProfileInfo.Pdp.Roaming)
1239                 *is_roaming = true;
1240         else
1241                 *is_roaming = false;
1242
1243         return CONNECTION_ERROR_NONE;
1244 }
1245
1246 int connection_profile_set_cellular_service_type(connection_profile_h profile,
1247                 connection_cellular_service_type_e service_type)
1248 {
1249         if (!(_connection_libnet_check_profile_validity(profile))) {
1250                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1251                 return CONNECTION_ERROR_INVALID_PARAMETER;
1252         }
1253
1254         net_profile_info_t *profile_info = profile;
1255
1256         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1257                 return CONNECTION_ERROR_INVALID_PARAMETER;
1258
1259         switch (service_type) {
1260         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1261                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1262                 break;
1263         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1264                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1265                 break;
1266         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1267                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1268                 break;
1269         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1270                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1271                 break;
1272         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1273                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1274                 break;
1275         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1276                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1277                 break;
1278         case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1279         default:
1280                 return CONNECTION_ERROR_INVALID_PARAMETER;
1281         }
1282
1283         return CONNECTION_ERROR_NONE;
1284 }
1285
1286 int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1287 {
1288         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1289                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1290                 return CONNECTION_ERROR_INVALID_PARAMETER;
1291         }
1292
1293         net_profile_info_t *profile_info = profile;
1294
1295         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1296                 return CONNECTION_ERROR_INVALID_PARAMETER;
1297
1298         g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1299
1300         return CONNECTION_ERROR_NONE;
1301 }
1302
1303 int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1304                 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1305 {
1306         if (!(_connection_libnet_check_profile_validity(profile)) ||
1307             user_name == NULL || password == NULL) {
1308                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1309                 return CONNECTION_ERROR_INVALID_PARAMETER;
1310         }
1311
1312         net_profile_info_t *profile_info = profile;
1313
1314         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1315                 return CONNECTION_ERROR_INVALID_PARAMETER;
1316
1317         switch (type) {
1318         case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1319                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1320                 break;
1321         case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1322                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1323                 break;
1324         case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1325                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1326                 break;
1327         default:
1328                 return CONNECTION_ERROR_INVALID_PARAMETER;
1329         }
1330
1331         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1332         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1333
1334         return CONNECTION_ERROR_NONE;
1335 }
1336
1337 int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1338 {
1339         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1340                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1341                 return CONNECTION_ERROR_INVALID_PARAMETER;
1342         }
1343
1344         net_profile_info_t *profile_info = profile;
1345
1346         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1347                 return CONNECTION_ERROR_INVALID_PARAMETER;
1348
1349         g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1350
1351         return CONNECTION_ERROR_NONE;
1352 }
1353