src/net_wifi_ap.c

   1 /*
   2  * Copyright (c) 2012-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 <arpa/inet.h>
  20 #include <glib.h>
  21 #include "net_wifi_private.h"
  22
  23 static char* __ap_convert_ip_to_string(net_addr_t *ip_addr)
  24 {
  25         unsigned char *ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
  26
  27         char *ipstr = g_try_malloc0(16);
  28         if (ipstr == NULL)
  29                 return NULL;
  30
  31         g_snprintf(ipstr, 16, "%d.%d.%d.%d", ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3]);
  32
  33         return ipstr;
  34 }
  35
  36 static void __wifi_init_ap(net_profile_info_t *profile_info, const char *essid)
  37 {
  38         profile_info->profile_type = NET_DEVICE_WIFI;
  39         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
  40         profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
  41         profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
  42         profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
  43         profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
  44         profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
  45         g_strlcpy(profile_info->ProfileInfo.Wlan.essid, essid, NET_WLAN_ESSID_LEN+1);
  46 }
  47
  48 static char *__wifi_create_profile_name(const char *ssid, const int net_mode, const int sec_mode)
  49 {
  50         char *buf = NULL;
  51         char *pbuf = NULL;
  52         const char *hidden_str = "hidden";
  53         char buf_tmp[32] = { 0, };
  54         int i;
  55         int ssid_len = 0;
  56         int actual_len = 0;
  57         const char *mode = "managed";
  58         char *g_sec = NULL;
  59
  60         if (net_mode == NETPM_WLAN_CONNMODE_ADHOC) {
  61                 WIFI_LOG(WIFI_ERROR, "wlan_mode is adhoc");
  62                 return NULL;
  63         }
  64
  65         switch (sec_mode) {
  66         case WLAN_SEC_MODE_NONE:
  67                 g_sec = "none";
  68                 break;
  69         case WLAN_SEC_MODE_WEP:
  70                 g_sec = "wep";
  71                 break;
  72         case WLAN_SEC_MODE_WPA_PSK:
  73         case WLAN_SEC_MODE_WPA2_PSK:
  74                 g_sec = "psk";
  75                 break;
  76         case WLAN_SEC_MODE_IEEE8021X:
  77                 g_sec = "ieee8021x";
  78                 break;
  79         default:
  80                 WIFI_LOG(WIFI_ERROR, "Invalid security type");
  81                 return NULL;
  82         }
  83
  84         if (NULL != ssid) {
  85                 ssid_len = strlen(ssid);
  86                 actual_len = ssid_len * 2;
  87         } else {
  88                 ssid_len = strlen(hidden_str);
  89                 actual_len = ssid_len;
  90         }
  91
  92         buf = g_try_malloc0(actual_len + strlen(mode) + strlen(g_sec) + 3);
  93         if (buf == NULL)
  94                 return NULL;
  95
  96         if (NULL != ssid) {
  97                 pbuf = buf;
  98
  99                 for (i = 0; i < ssid_len; i++) {
 100                         g_snprintf(pbuf, 3, "%02x", ssid[i]);
 101                         pbuf += 2;
 102                 }
 103         } else
 104                 g_strlcat(buf, hidden_str,
 105                                 actual_len + strlen(mode) + strlen(g_sec) + 3);
 106
 107         g_snprintf(buf_tmp, 32, "_%s_%s", mode, g_sec);
 108         g_strlcat(buf, buf_tmp,
 109                         actual_len + strlen(mode) + strlen(g_sec) + 3);
 110
 111         WIFI_LOG(WIFI_INFO, "Profile name: %s", buf);
 112
 113         return buf;
 114 }
 115
 116 static bool _wifi_set_profile_name_to_ap(net_profile_info_t *ap_info)
 117 {
 118         char *profile_name = NULL;
 119
 120         if (ap_info == NULL) {
 121                 WIFI_LOG(WIFI_ERROR, "profile_info is NULL");
 122                 return false;
 123         }
 124
 125         profile_name = __wifi_create_profile_name(
 126                         ap_info->ProfileInfo.Wlan.essid,
 127                         ap_info->ProfileInfo.Wlan.wlan_mode,
 128                         ap_info->ProfileInfo.Wlan.security_info.sec_mode);
 129         if (profile_name == NULL) {
 130                 WIFI_LOG(WIFI_ERROR, "Failed to make a group name");
 131                 return false;
 132         }
 133
 134         g_strlcpy(ap_info->ProfileInfo.Wlan.net_info.ProfileName,
 135                         profile_name, NET_PROFILE_NAME_LEN_MAX);
 136
 137         g_free(profile_name);
 138
 139         return true;
 140 }
 141
 142 wifi_connection_state_e _wifi_convert_to_ap_state(net_state_type_t state)
 143 {
 144         wifi_connection_state_e ap_state;
 145
 146         switch (state) {
 147         case NET_STATE_TYPE_ONLINE:
 148         case NET_STATE_TYPE_READY:
 149                 ap_state = WIFI_CONNECTION_STATE_CONNECTED;
 150                 break;
 151         case NET_STATE_TYPE_FAILURE:
 152                 ap_state = WIFI_CONNECTION_STATE_FAILURE;
 153                 break;
 154         case NET_STATE_TYPE_IDLE:
 155         case NET_STATE_TYPE_DISCONNECT:
 156                 ap_state = WIFI_CONNECTION_STATE_DISCONNECTED;
 157                 break;
 158         case NET_STATE_TYPE_ASSOCIATION:
 159                 ap_state = WIFI_CONNECTION_STATE_ASSOCIATION;
 160                 break;
 161         case NET_STATE_TYPE_CONFIGURATION:
 162                 ap_state = WIFI_CONNECTION_STATE_CONFIGURATION;
 163                 break;
 164         default:
 165                 ap_state = -1;
 166                 break;
 167         }
 168
 169         return ap_state;
 170 }
 171
 172 /* Wi-Fi AP ******************************************************************/
 173 EXPORT_API int wifi_ap_create(const char* essid, wifi_ap_h* ap)
 174 {
 175         if (essid == NULL || ap == NULL) {
 176                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 177                 return WIFI_ERROR_INVALID_PARAMETER;
 178         }
 179
 180         net_profile_info_t *ap_info = g_try_malloc0(sizeof(net_profile_info_t));
 181         if (ap_info == NULL)
 182                 return WIFI_ERROR_OUT_OF_MEMORY;
 183
 184         __wifi_init_ap(ap_info, essid);
 185
 186         _wifi_libnet_add_to_ap_list((wifi_ap_h)ap_info);
 187         *ap = (wifi_ap_h)ap_info;
 188
 189         return WIFI_ERROR_NONE;
 190 }
 191
 192 EXPORT_API int wifi_ap_hidden_create(const char* essid, wifi_ap_h* ap)
 193 {
 194         if (essid == NULL || ap == NULL) {
 195                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 196                 return WIFI_ERROR_INVALID_PARAMETER;
 197         }
 198
 199         net_profile_info_t *ap_info = g_try_malloc0(sizeof(net_profile_info_t));
 200         if (ap_info == NULL)
 201                 return WIFI_ERROR_OUT_OF_MEMORY;
 202
 203         __wifi_init_ap(ap_info, essid);
 204         ap_info->ProfileInfo.Wlan.is_hidden = TRUE;
 205
 206         _wifi_libnet_add_to_ap_list((wifi_ap_h)ap_info);
 207         *ap = (wifi_ap_h)ap_info;
 208
 209         return WIFI_ERROR_NONE;
 210 }
 211
 212 EXPORT_API int wifi_ap_destroy(wifi_ap_h ap)
 213 {
 214         if (_wifi_libnet_check_ap_validity(ap) == false) {
 215                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 216                 return WIFI_ERROR_INVALID_PARAMETER;
 217         }
 218
 219         _wifi_libnet_remove_from_ap_list(ap);
 220
 221         return WIFI_ERROR_NONE;
 222 }
 223
 224 EXPORT_API int wifi_ap_clone(wifi_ap_h* cloned_ap, wifi_ap_h origin)
 225 {
 226         if (_wifi_libnet_check_ap_validity(origin) == false || cloned_ap == NULL) {
 227                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 228                 return WIFI_ERROR_INVALID_PARAMETER;
 229         }
 230
 231         net_profile_info_t *ap_info = g_try_malloc0(sizeof(net_profile_info_t));
 232         if (ap_info == NULL)
 233                 return WIFI_ERROR_OUT_OF_MEMORY;
 234
 235         memcpy(ap_info, origin, sizeof(net_profile_info_t));
 236
 237         _wifi_libnet_add_to_ap_list((wifi_ap_h)ap_info);
 238         *cloned_ap = (wifi_ap_h)ap_info;
 239
 240         return WIFI_ERROR_NONE;
 241 }
 242
 243 EXPORT_API int wifi_ap_refresh(wifi_ap_h ap)
 244 {
 245         net_profile_info_t ap_info_local;
 246         net_profile_info_t *ap_info = ap;
 247
 248         if (_wifi_libnet_check_ap_validity(ap) == false) {
 249                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 250                 return WIFI_ERROR_INVALID_PARAMETER;
 251         }
 252
 253         int rv = NET_ERR_NONE;
 254         rv = net_get_profile_info(ap_info->ProfileName, &ap_info_local);
 255         if (rv == NET_ERR_ACCESS_DENIED) {
 256                 WIFI_LOG(WIFI_ERROR, "Access denied");
 257                 return WIFI_ERROR_PERMISSION_DENIED;
 258         } else if (rv != NET_ERR_NONE) {
 259                 WIFI_LOG(WIFI_ERROR, "Failed to getprofile_info");
 260                 return WIFI_ERROR_OPERATION_FAILED;
 261         }
 262
 263         memcpy(ap, &ap_info_local, sizeof(net_profile_info_t));
 264
 265         return WIFI_ERROR_NONE;
 266 }
 267
 268 /* Wi-Fi network information *************************************************/
 269 EXPORT_API int wifi_ap_get_essid(wifi_ap_h ap, char** essid)
 270 {
 271         if (_wifi_libnet_check_ap_validity(ap) == false || essid == NULL) {
 272                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 273                 return WIFI_ERROR_INVALID_PARAMETER;
 274         }
 275
 276         net_profile_info_t *profile_info = ap;
 277         *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
 278         if (*essid == NULL)
 279                 return WIFI_ERROR_OUT_OF_MEMORY;
 280
 281         return WIFI_ERROR_NONE;
 282 }
 283
 284 EXPORT_API int wifi_ap_get_bssid(wifi_ap_h ap, char** bssid)
 285 {
 286         if (_wifi_libnet_check_ap_validity(ap) == false || bssid == NULL) {
 287                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 288                 return WIFI_ERROR_INVALID_PARAMETER;
 289         }
 290
 291         net_profile_info_t *profile_info = ap;
 292         *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
 293         if (*bssid == NULL)
 294                 return WIFI_ERROR_OUT_OF_MEMORY;
 295
 296         return WIFI_ERROR_NONE;
 297 }
 298
 299 EXPORT_API int wifi_ap_get_rssi(wifi_ap_h ap, int* rssi)
 300 {
 301         if (_wifi_libnet_check_ap_validity(ap) == false || rssi == NULL) {
 302                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 303                 return WIFI_ERROR_INVALID_PARAMETER;
 304         }
 305
 306         net_profile_info_t *profile_info = ap;
 307         *rssi = (int)(profile_info->ProfileInfo.Wlan.Strength - 120);
 308
 309         return WIFI_ERROR_NONE;
 310 }
 311
 312 EXPORT_API int wifi_ap_get_frequency(wifi_ap_h ap, int* frequency)
 313 {
 314         if (_wifi_libnet_check_ap_validity(ap) == false || frequency == NULL) {
 315                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 316                 return WIFI_ERROR_INVALID_PARAMETER;
 317         }
 318
 319         net_profile_info_t *profile_info = ap;
 320         *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
 321
 322         return WIFI_ERROR_NONE;
 323 }
 324
 325 EXPORT_API int wifi_ap_get_max_speed(wifi_ap_h ap, int* max_speed)
 326 {
 327         if (_wifi_libnet_check_ap_validity(ap) == false || max_speed == NULL) {
 328                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 329                 return WIFI_ERROR_INVALID_PARAMETER;
 330         }
 331
 332         net_profile_info_t *profile_info = ap;
 333         *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate / 1000000;
 334
 335         return WIFI_ERROR_NONE;
 336 }
 337
 338 EXPORT_API int wifi_ap_is_favorite(wifi_ap_h ap, bool* favorite)
 339 {
 340         if (_wifi_libnet_check_ap_validity(ap) == false || favorite == NULL) {
 341                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 342                 return WIFI_ERROR_INVALID_PARAMETER;
 343         }
 344
 345         net_profile_info_t *profile_info = ap;
 346
 347         if (profile_info->Favourite)
 348                 *favorite = true;
 349         else
 350                 *favorite = false;
 351
 352         return WIFI_ERROR_NONE;
 353 }
 354
 355 EXPORT_API int wifi_ap_is_passpoint(wifi_ap_h ap, bool* passpoint)
 356 {
 357         if (_wifi_libnet_check_ap_validity(ap) == false || passpoint == NULL) {
 358                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 359                 return WIFI_ERROR_INVALID_PARAMETER;
 360         }
 361
 362         net_profile_info_t *profile_info = ap;
 363
 364         if (profile_info->ProfileInfo.Wlan.passpoint)
 365                 *passpoint = true;
 366         else
 367                 *passpoint = false;
 368
 369         return WIFI_ERROR_NONE;
 370 }
 371
 372 EXPORT_API int wifi_ap_get_connection_state(wifi_ap_h ap, wifi_connection_state_e* state)
 373 {
 374         if (_wifi_libnet_check_ap_validity(ap) == false || state == NULL) {
 375                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 376                 return WIFI_ERROR_INVALID_PARAMETER;
 377         }
 378
 379         net_profile_info_t *profile_info = ap;
 380
 381         *state = _wifi_convert_to_ap_state(profile_info->ProfileState);
 382
 383         if (*state < 0)
 384                 return WIFI_ERROR_OPERATION_FAILED;
 385
 386         return WIFI_ERROR_NONE;
 387 }
 388
 389 EXPORT_API int wifi_ap_get_ip_config_type(wifi_ap_h ap, wifi_address_family_e address_family, wifi_ip_config_type_e* type)
 390 {
 391         if (_wifi_libnet_check_ap_validity(ap) == false ||
 392             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 393              address_family != WIFI_ADDRESS_FAMILY_IPV6) ||
 394             type == NULL) {
 395                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 396                 return WIFI_ERROR_INVALID_PARAMETER;
 397         }
 398
 399         if (address_family == WIFI_ADDRESS_FAMILY_IPV6) {
 400                 WIFI_LOG(WIFI_ERROR, "Not supported yet");
 401                 return WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 402         }
 403
 404         net_profile_info_t *profile_info = ap;
 405
 406         switch (profile_info->ProfileInfo.Wlan.net_info.IpConfigType) {
 407         case NET_IP_CONFIG_TYPE_STATIC:
 408                 *type = WIFI_IP_CONFIG_TYPE_STATIC;
 409                 break;
 410         case NET_IP_CONFIG_TYPE_DYNAMIC:
 411                 *type = WIFI_IP_CONFIG_TYPE_DYNAMIC;
 412                 break;
 413         case NET_IP_CONFIG_TYPE_AUTO_IP:
 414                 *type = WIFI_IP_CONFIG_TYPE_AUTO;
 415                 break;
 416         case NET_IP_CONFIG_TYPE_FIXED:
 417                 *type = WIFI_IP_CONFIG_TYPE_FIXED;
 418                 break;
 419         case NET_IP_CONFIG_TYPE_OFF:
 420                 *type = WIFI_IP_CONFIG_TYPE_NONE;
 421                 break;
 422         default:
 423                 return WIFI_ERROR_OPERATION_FAILED;
 424         }
 425
 426         return WIFI_ERROR_NONE;
 427 }
 428
 429 EXPORT_API int wifi_ap_set_ip_config_type(wifi_ap_h ap, wifi_address_family_e address_family, wifi_ip_config_type_e type)
 430 {
 431         if (_wifi_libnet_check_ap_validity(ap) == false ||
 432             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 433              address_family != WIFI_ADDRESS_FAMILY_IPV6)) {
 434                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 435                 return WIFI_ERROR_INVALID_PARAMETER;
 436         }
 437
 438         if (address_family == WIFI_ADDRESS_FAMILY_IPV6) {
 439                 WIFI_LOG(WIFI_ERROR, "Not supported yet");
 440                 return WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 441         }
 442
 443         net_profile_info_t *profile_info = ap;
 444
 445         switch (type) {
 446         case WIFI_IP_CONFIG_TYPE_STATIC:
 447                 profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_STATIC;
 448                 break;
 449         case WIFI_IP_CONFIG_TYPE_DYNAMIC:
 450                 profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_DYNAMIC;
 451                 break;
 452         case WIFI_IP_CONFIG_TYPE_AUTO:
 453                 profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_AUTO_IP;
 454                 break;
 455         case WIFI_IP_CONFIG_TYPE_FIXED:
 456                 profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
 457                 break;
 458         case WIFI_IP_CONFIG_TYPE_NONE:
 459                 profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
 460                 break;
 461         default:
 462                 return WIFI_ERROR_INVALID_PARAMETER;
 463         }
 464
 465         if (_wifi_libnet_check_profile_name_validity(profile_info->ProfileName) == false)
 466                 return WIFI_ERROR_NONE;
 467
 468         return _wifi_update_ap_info(profile_info);
 469 }
 470
 471 EXPORT_API int wifi_ap_get_ip_address(wifi_ap_h ap, wifi_address_family_e address_family, char** ip_address)
 472 {
 473         if (_wifi_libnet_check_ap_validity(ap) == false ||
 474             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 475              address_family != WIFI_ADDRESS_FAMILY_IPV6) ||
 476             ip_address == NULL) {
 477                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 478                 return WIFI_ERROR_INVALID_PARAMETER;
 479         }
 480
 481         if (address_family == WIFI_ADDRESS_FAMILY_IPV6) {
 482                 WIFI_LOG(WIFI_ERROR, "Not supported yet");
 483                 return WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 484         }
 485
 486         net_profile_info_t *profile_info = ap;
 487         *ip_address = __ap_convert_ip_to_string(&profile_info->ProfileInfo.Wlan.net_info.IpAddr);
 488         if (*ip_address == NULL)
 489                 return WIFI_ERROR_OUT_OF_MEMORY;
 490
 491         return WIFI_ERROR_NONE;
 492 }
 493
 494 EXPORT_API int wifi_ap_set_ip_address(wifi_ap_h ap, wifi_address_family_e address_family, const char* ip_address)
 495 {
 496         if (_wifi_libnet_check_ap_validity(ap) == false ||
 497             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 498              address_family != WIFI_ADDRESS_FAMILY_IPV6)) {
 499                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 500                 return WIFI_ERROR_INVALID_PARAMETER;
 501         }
 502
 503         if (address_family == WIFI_ADDRESS_FAMILY_IPV6) {
 504                 WIFI_LOG(WIFI_ERROR, "Not supported yet");
 505                 return WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 506         }
 507
 508         net_profile_info_t *profile_info = ap;
 509
 510         if (ip_address == NULL)
 511                 profile_info->ProfileInfo.Wlan.net_info.IpAddr.Data.Ipv4.s_addr = 0;
 512         else if (inet_aton(ip_address, &(profile_info->ProfileInfo.Wlan.net_info.IpAddr.Data.Ipv4)) == 0)
 513                 return WIFI_ERROR_INVALID_PARAMETER;
 514
 515         if (_wifi_libnet_check_profile_name_validity(profile_info->ProfileName) == false)
 516                 return WIFI_ERROR_NONE;
 517
 518         return _wifi_update_ap_info(profile_info);
 519 }
 520
 521 EXPORT_API int wifi_ap_get_subnet_mask(wifi_ap_h ap, wifi_address_family_e address_family, char** subnet_mask)
 522 {
 523         if (_wifi_libnet_check_ap_validity(ap) == false ||
 524             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 525              address_family != WIFI_ADDRESS_FAMILY_IPV6) ||
 526             subnet_mask == NULL) {
 527                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 528                 return WIFI_ERROR_INVALID_PARAMETER;
 529         }
 530
 531         if (address_family == WIFI_ADDRESS_FAMILY_IPV6) {
 532                 WIFI_LOG(WIFI_ERROR, "Not supported yet");
 533                 return WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 534         }
 535
 536         net_profile_info_t *profile_info = ap;
 537         *subnet_mask = __ap_convert_ip_to_string(&profile_info->ProfileInfo.Wlan.net_info.SubnetMask);
 538         if (*subnet_mask == NULL)
 539                 return WIFI_ERROR_OUT_OF_MEMORY;
 540
 541         return WIFI_ERROR_NONE;
 542 }
 543
 544 EXPORT_API int wifi_ap_set_subnet_mask(wifi_ap_h ap, wifi_address_family_e address_family, const char* subnet_mask)
 545 {
 546         if (_wifi_libnet_check_ap_validity(ap) == false ||
 547             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 548              address_family != WIFI_ADDRESS_FAMILY_IPV6)) {
 549                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 550                 return WIFI_ERROR_INVALID_PARAMETER;
 551         }
 552
 553         if (address_family == WIFI_ADDRESS_FAMILY_IPV6) {
 554                 WIFI_LOG(WIFI_ERROR, "Not supported yet");
 555                 return WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 556         }
 557
 558         net_profile_info_t *profile_info = ap;
 559
 560         if (subnet_mask == NULL)
 561                 profile_info->ProfileInfo.Wlan.net_info.SubnetMask.Data.Ipv4.s_addr = 0;
 562         else if (inet_aton(subnet_mask, &(profile_info->ProfileInfo.Wlan.net_info.SubnetMask.Data.Ipv4)) == 0)
 563                 return WIFI_ERROR_INVALID_PARAMETER;
 564
 565         if (_wifi_libnet_check_profile_name_validity(profile_info->ProfileName) == false)
 566                 return WIFI_ERROR_NONE;
 567
 568         return _wifi_update_ap_info(profile_info);
 569 }
 570
 571 EXPORT_API int wifi_ap_get_gateway_address(wifi_ap_h ap, wifi_address_family_e address_family, char** gateway_address)
 572 {
 573         if (_wifi_libnet_check_ap_validity(ap) == false ||
 574             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 575              address_family != WIFI_ADDRESS_FAMILY_IPV6) ||
 576             gateway_address == NULL) {
 577                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 578                 return WIFI_ERROR_INVALID_PARAMETER;
 579         }
 580
 581         if (address_family == WIFI_ADDRESS_FAMILY_IPV6) {
 582                 WIFI_LOG(WIFI_ERROR, "Not supported yet");
 583                 return WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 584         }
 585
 586         net_profile_info_t *profile_info = ap;
 587         *gateway_address = __ap_convert_ip_to_string(&profile_info->ProfileInfo.Wlan.net_info.GatewayAddr);
 588         if (*gateway_address == NULL)
 589                 return WIFI_ERROR_OUT_OF_MEMORY;
 590
 591         return WIFI_ERROR_NONE;
 592 }
 593
 594 EXPORT_API int wifi_ap_set_gateway_address(wifi_ap_h ap, wifi_address_family_e address_family, const char* gateway_address)
 595 {
 596         if (_wifi_libnet_check_ap_validity(ap) == false ||
 597             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 598              address_family != WIFI_ADDRESS_FAMILY_IPV6)) {
 599                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 600                 return WIFI_ERROR_INVALID_PARAMETER;
 601         }
 602
 603         if (address_family == WIFI_ADDRESS_FAMILY_IPV6) {
 604                 WIFI_LOG(WIFI_ERROR, "Not supported yet");
 605                 return WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 606         }
 607
 608         net_profile_info_t *profile_info = ap;
 609
 610         if (gateway_address == NULL)
 611                 profile_info->ProfileInfo.Wlan.net_info.GatewayAddr.Data.Ipv4.s_addr = 0;
 612         else if (inet_aton(gateway_address, &(profile_info->ProfileInfo.Wlan.net_info.GatewayAddr.Data.Ipv4)) == 0)
 613                 return WIFI_ERROR_INVALID_PARAMETER;
 614
 615         if (_wifi_libnet_check_profile_name_validity(profile_info->ProfileName) == false)
 616                 return WIFI_ERROR_NONE;
 617
 618         return _wifi_update_ap_info(profile_info);
 619 }
 620
 621 EXPORT_API int wifi_ap_get_proxy_address(wifi_ap_h ap, wifi_address_family_e address_family, char** proxy_address)
 622 {
 623         if (_wifi_libnet_check_ap_validity(ap) == false ||
 624             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 625              address_family != WIFI_ADDRESS_FAMILY_IPV6) ||
 626             proxy_address == NULL) {
 627                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 628                 return WIFI_ERROR_INVALID_PARAMETER;
 629         }
 630
 631         if (address_family == WIFI_ADDRESS_FAMILY_IPV6) {
 632                 WIFI_LOG(WIFI_ERROR, "Not supported yet");
 633                 return WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 634         }
 635
 636         net_profile_info_t *profile_info = ap;
 637         *proxy_address = g_strdup(profile_info->ProfileInfo.Wlan.net_info.ProxyAddr);
 638         if (*proxy_address == NULL)
 639                 return WIFI_ERROR_OUT_OF_MEMORY;
 640
 641         return WIFI_ERROR_NONE;
 642 }
 643
 644 EXPORT_API int wifi_ap_set_proxy_address(wifi_ap_h ap, wifi_address_family_e address_family, const char* proxy_address)
 645 {
 646         if (_wifi_libnet_check_ap_validity(ap) == false ||
 647             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 648              address_family != WIFI_ADDRESS_FAMILY_IPV6)) {
 649                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 650                 return WIFI_ERROR_INVALID_PARAMETER;
 651         }
 652
 653         if (address_family == WIFI_ADDRESS_FAMILY_IPV6) {
 654                 WIFI_LOG(WIFI_ERROR, "Not supported yet");
 655                 return WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 656         }
 657
 658         net_profile_info_t *profile_info = ap;
 659
 660         if (proxy_address == NULL)
 661                 profile_info->ProfileInfo.Wlan.net_info.ProxyAddr[0] = '\0';
 662         else
 663                 g_strlcpy(profile_info->ProfileInfo.Wlan.net_info.ProxyAddr,
 664                                 proxy_address, NET_PROXY_LEN_MAX+1);
 665
 666         if (_wifi_libnet_check_profile_name_validity(profile_info->ProfileName) == false)
 667                 return WIFI_ERROR_NONE;
 668
 669         return _wifi_update_ap_info(profile_info);
 670 }
 671
 672 EXPORT_API int wifi_ap_get_proxy_type(wifi_ap_h ap, wifi_proxy_type_e* type)
 673 {
 674         if (_wifi_libnet_check_ap_validity(ap) == false || type == NULL) {
 675                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 676                 return WIFI_ERROR_INVALID_PARAMETER;
 677         }
 678
 679         net_profile_info_t *profile_info = ap;
 680
 681         switch (profile_info->ProfileInfo.Wlan.net_info.ProxyMethod) {
 682         case NET_PROXY_TYPE_DIRECT:
 683                 *type = WIFI_PROXY_TYPE_DIRECT;
 684                 break;
 685         case NET_PROXY_TYPE_AUTO:
 686                 *type = WIFI_PROXY_TYPE_AUTO;
 687                 break;
 688         case NET_PROXY_TYPE_MANUAL:
 689                 *type = WIFI_PROXY_TYPE_MANUAL;
 690                 break;
 691         case NET_PROXY_TYPE_UNKNOWN:
 692                 *type = WIFI_PROXY_TYPE_DIRECT;
 693                 break;
 694         default:
 695                 return WIFI_ERROR_OPERATION_FAILED;
 696         }
 697
 698         return WIFI_ERROR_NONE;
 699 }
 700
 701 EXPORT_API int wifi_ap_set_proxy_type(wifi_ap_h ap, wifi_proxy_type_e proxy_type)
 702 {
 703         if (_wifi_libnet_check_ap_validity(ap) == false) {
 704                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 705                 return WIFI_ERROR_INVALID_PARAMETER;
 706         }
 707
 708         net_profile_info_t *profile_info = ap;
 709         int rv;
 710
 711         switch (proxy_type) {
 712         case WIFI_PROXY_TYPE_DIRECT:
 713                 profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
 714                 break;
 715         case WIFI_PROXY_TYPE_AUTO:
 716                 profile_info->ProfileInfo.Wlan.net_info.ProxyAddr[0] = '\0';
 717                 profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_AUTO;
 718                 break;
 719         case WIFI_PROXY_TYPE_MANUAL:
 720                 profile_info->ProfileInfo.Wlan.net_info.ProxyAddr[0] = '\0';
 721                 profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_MANUAL;
 722                 break;
 723         default:
 724                 return WIFI_ERROR_INVALID_PARAMETER;
 725         }
 726
 727         if (_wifi_libnet_check_profile_name_validity(profile_info->ProfileName) == false)
 728                 return WIFI_ERROR_NONE;
 729
 730         rv =_wifi_update_ap_info(profile_info);
 731         if (rv != NET_ERR_NONE && proxy_type == WIFI_PROXY_TYPE_MANUAL) {
 732                 g_strlcpy(profile_info->ProfileInfo.Wlan.net_info.ProxyAddr, "0.0.0.0:8080", 15);
 733                 rv = _wifi_update_ap_info(profile_info);
 734         }
 735
 736         return rv;
 737 }
 738
 739 EXPORT_API int wifi_ap_get_dns_address(wifi_ap_h ap, int order, wifi_address_family_e address_family, char** dns_address)
 740 {
 741         if (_wifi_libnet_check_ap_validity(ap) == false ||
 742             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 743              address_family != WIFI_ADDRESS_FAMILY_IPV6) ||
 744             dns_address == NULL ||
 745             order <= 0 ||
 746             order > NET_DNS_ADDR_MAX) {
 747                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 748                 return WIFI_ERROR_INVALID_PARAMETER;
 749         }
 750
 751         if (address_family == WIFI_ADDRESS_FAMILY_IPV6) {
 752                 WIFI_LOG(WIFI_ERROR, "Not supported yet");
 753                 return WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 754         }
 755
 756         net_profile_info_t *profile_info = ap;
 757
 758         *dns_address = __ap_convert_ip_to_string(&profile_info->ProfileInfo.Wlan.net_info.DnsAddr[order-1]);
 759         if (*dns_address == NULL)
 760                 return WIFI_ERROR_OUT_OF_MEMORY;
 761
 762         return WIFI_ERROR_NONE;
 763 }
 764
 765 EXPORT_API int wifi_ap_set_dns_address(wifi_ap_h ap, int order, wifi_address_family_e address_family, const char* dns_address)
 766 {
 767         if (_wifi_libnet_check_ap_validity(ap) == false ||
 768             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 769              address_family != WIFI_ADDRESS_FAMILY_IPV6) ||
 770             order <= 0 ||
 771             order > NET_DNS_ADDR_MAX) {
 772                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 773                 return WIFI_ERROR_INVALID_PARAMETER;
 774         }
 775
 776         if (address_family == WIFI_ADDRESS_FAMILY_IPV6) {
 777                 WIFI_LOG(WIFI_ERROR, "Not supported yet");
 778                 return WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 779         }
 780
 781         net_profile_info_t *profile_info = ap;
 782
 783         if (dns_address == NULL)
 784                 profile_info->ProfileInfo.Wlan.net_info.DnsAddr[order-1].Data.Ipv4.s_addr = 0;
 785         else if (inet_aton(dns_address, &(profile_info->ProfileInfo.Wlan.net_info.DnsAddr[order-1].Data.Ipv4)) == 0)
 786                 return WIFI_ERROR_INVALID_PARAMETER;
 787
 788         if (profile_info->ProfileInfo.Wlan.net_info.DnsCount < order)
 789                 profile_info->ProfileInfo.Wlan.net_info.DnsCount = order;
 790
 791         if (_wifi_libnet_check_profile_name_validity(profile_info->ProfileName) == false)
 792                 return WIFI_ERROR_NONE;
 793
 794         return _wifi_update_ap_info(profile_info);
 795 }
 796
 797 /* Wi-Fi security information ************************************************/
 798 EXPORT_API int wifi_ap_get_security_type(wifi_ap_h ap, wifi_security_type_e* type)
 799 {
 800         if (_wifi_libnet_check_ap_validity(ap) == false || type == NULL) {
 801                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 802                 return WIFI_ERROR_INVALID_PARAMETER;
 803         }
 804
 805         net_profile_info_t *profile_info = ap;
 806
 807         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
 808         case WLAN_SEC_MODE_NONE:
 809                 *type = WIFI_SECURITY_TYPE_NONE;
 810                 break;
 811         case WLAN_SEC_MODE_WEP:
 812                 *type = WIFI_SECURITY_TYPE_WEP;
 813                 break;
 814         case WLAN_SEC_MODE_IEEE8021X:
 815                 *type = WIFI_SECURITY_TYPE_EAP;
 816                 break;
 817         case WLAN_SEC_MODE_WPA_PSK:
 818                 *type = WIFI_SECURITY_TYPE_WPA_PSK;
 819                 break;
 820         case WLAN_SEC_MODE_WPA2_PSK:
 821                 *type = WIFI_SECURITY_TYPE_WPA2_PSK;
 822                 break;
 823         default:
 824                 return WIFI_ERROR_OPERATION_FAILED;
 825         }
 826
 827         return WIFI_ERROR_NONE;
 828 }
 829
 830 EXPORT_API int wifi_ap_set_security_type(wifi_ap_h ap, wifi_security_type_e type)
 831 {
 832         if (_wifi_libnet_check_ap_validity(ap) == false) {
 833                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 834                 return WIFI_ERROR_INVALID_PARAMETER;
 835         }
 836
 837         net_profile_info_t *profile_info = ap;
 838
 839         switch (type) {
 840         case WIFI_SECURITY_TYPE_NONE:
 841                 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
 842                 break;
 843         case WIFI_SECURITY_TYPE_WEP:
 844                 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_WEP;
 845                 break;
 846         case WIFI_SECURITY_TYPE_EAP:
 847                 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_IEEE8021X;
 848                 break;
 849         case WIFI_SECURITY_TYPE_WPA_PSK:
 850                 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_WPA_PSK;
 851                 break;
 852         case WIFI_SECURITY_TYPE_WPA2_PSK:
 853                 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_WPA2_PSK;
 854                 break;
 855         default:
 856                 return WIFI_ERROR_INVALID_PARAMETER;
 857         }
 858
 859         _wifi_set_profile_name_to_ap(profile_info);
 860
 861         return WIFI_ERROR_NONE;
 862 }
 863
 864 EXPORT_API int wifi_ap_get_encryption_type(wifi_ap_h ap, wifi_encryption_type_e* type)
 865 {
 866         if (_wifi_libnet_check_ap_validity(ap) == false || type == NULL) {
 867                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 868                 return WIFI_ERROR_INVALID_PARAMETER;
 869         }
 870
 871         net_profile_info_t *profile_info = ap;
 872
 873         switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
 874         case WLAN_ENC_MODE_NONE:
 875                 *type = WIFI_ENCRYPTION_TYPE_NONE;
 876                 break;
 877         case WLAN_ENC_MODE_WEP:
 878                 *type = WIFI_ENCRYPTION_TYPE_WEP;
 879                 break;
 880         case WLAN_ENC_MODE_TKIP:
 881                 *type = WIFI_ENCRYPTION_TYPE_TKIP;
 882                 break;
 883         case WLAN_ENC_MODE_AES:
 884                 *type = WIFI_ENCRYPTION_TYPE_AES;
 885                 break;
 886         case WLAN_ENC_MODE_TKIP_AES_MIXED:
 887                 *type = WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
 888                 break;
 889         default:
 890                 return WIFI_ERROR_OPERATION_FAILED;
 891         }
 892
 893         return WIFI_ERROR_NONE;
 894 }
 895
 896 EXPORT_API int wifi_ap_set_encryption_type(wifi_ap_h ap, wifi_encryption_type_e type)
 897 {
 898         if (_wifi_libnet_check_ap_validity(ap) == false) {
 899                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 900                 return WIFI_ERROR_INVALID_PARAMETER;
 901         }
 902
 903         net_profile_info_t *profile_info = ap;
 904
 905         switch (type) {
 906         case WIFI_ENCRYPTION_TYPE_NONE:
 907                 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
 908                 break;
 909         case WIFI_ENCRYPTION_TYPE_WEP:
 910                 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_WEP;
 911                 break;
 912         case WIFI_ENCRYPTION_TYPE_TKIP:
 913                 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_TKIP;
 914                 break;
 915         case WIFI_ENCRYPTION_TYPE_AES:
 916                 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_AES;
 917                 break;
 918         case WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED:
 919                 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_TKIP_AES_MIXED;
 920                 break;
 921         default:
 922                 return WIFI_ERROR_INVALID_PARAMETER;
 923         }
 924
 925         return WIFI_ERROR_NONE;
 926 }
 927
 928 EXPORT_API int wifi_ap_is_passphrase_required(wifi_ap_h ap, bool* required)
 929 {
 930         if (_wifi_libnet_check_ap_validity(ap) == false || required == NULL) {
 931                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 932                 return WIFI_ERROR_INVALID_PARAMETER;
 933         }
 934
 935         net_profile_info_t *profile_info = ap;
 936
 937         if (profile_info->Favourite) {
 938                 *required = false;
 939                 return WIFI_ERROR_NONE;
 940         }
 941
 942         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
 943         case WLAN_SEC_MODE_NONE:
 944                 *required = false;
 945                 break;
 946         case WLAN_SEC_MODE_WEP:
 947         case WLAN_SEC_MODE_IEEE8021X:
 948         case WLAN_SEC_MODE_WPA_PSK:
 949         case WLAN_SEC_MODE_WPA2_PSK:
 950                 *required = true;
 951                 break;
 952         default:
 953                 return WIFI_ERROR_OPERATION_FAILED;
 954         }
 955
 956         return WIFI_ERROR_NONE;
 957 }
 958
 959 EXPORT_API int wifi_ap_set_passphrase(wifi_ap_h ap, const char* passphrase)
 960 {
 961         if (_wifi_libnet_check_ap_validity(ap) == false || passphrase == NULL) {
 962                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 963                 return WIFI_ERROR_INVALID_PARAMETER;
 964         }
 965
 966         net_profile_info_t *profile_info = ap;
 967
 968         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
 969         case WLAN_SEC_MODE_WEP:
 970                 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.wep.wepKey,
 971                                 passphrase, NETPM_WLAN_MAX_WEP_KEY_LEN+1);
 972                 break;
 973         case WLAN_SEC_MODE_WPA_PSK:
 974         case WLAN_SEC_MODE_WPA2_PSK:
 975                 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
 976                                 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN+1);
 977                 break;
 978         case WLAN_SEC_MODE_NONE:
 979         case WLAN_SEC_MODE_IEEE8021X:
 980         default:
 981                 return WIFI_ERROR_OPERATION_FAILED;
 982         }
 983
 984         return WIFI_ERROR_NONE;
 985 }
 986
 987 EXPORT_API int wifi_ap_is_wps_supported(wifi_ap_h ap, bool* supported)
 988 {
 989         if (_wifi_libnet_check_ap_validity(ap) == false || supported == NULL) {
 990                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 991                 return WIFI_ERROR_INVALID_PARAMETER;
 992         }
 993
 994         net_profile_info_t *profile_info = ap;
 995
 996         if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
 997                 *supported = true;
 998         else
 999                 *supported = false;
1000
1001         return WIFI_ERROR_NONE;
1002 }
1003
1004 /* Wi-Fi EAP *****************************************************************/
1005 EXPORT_API int wifi_ap_set_eap_passphrase(wifi_ap_h ap, const char* user_name, const char* password)
1006 {
1007         if (_wifi_libnet_check_ap_validity(ap) == false || (user_name == NULL && password == NULL)) {
1008                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1009                 return WIFI_ERROR_INVALID_PARAMETER;
1010         }
1011
1012         net_profile_info_t *profile_info = ap;
1013         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1014                 return WIFI_ERROR_INVALID_OPERATION;
1015
1016         if (user_name)
1017                 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.username,
1018                                 user_name, NETPM_WLAN_USERNAME_LEN+1);
1019
1020         if (password)
1021                 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.password,
1022                                 password, NETPM_WLAN_PASSWORD_LEN+1);
1023
1024         return WIFI_ERROR_NONE;
1025 }
1026
1027 EXPORT_API int wifi_ap_get_eap_passphrase(wifi_ap_h ap, char** user_name, bool* is_password_set)
1028 {
1029         if (_wifi_libnet_check_ap_validity(ap) == false ||user_name == NULL || is_password_set == NULL) {
1030                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1031                 return WIFI_ERROR_INVALID_PARAMETER;
1032         }
1033
1034         net_profile_info_t *profile_info = ap;
1035         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1036                 return WIFI_ERROR_INVALID_OPERATION;
1037
1038         *user_name = g_strdup(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.username);
1039         if (*user_name == NULL)
1040                 return WIFI_ERROR_OUT_OF_MEMORY;
1041
1042         if (strlen(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.password) > 0)
1043                 *is_password_set = true;
1044         else
1045                 *is_password_set = false;
1046
1047
1048         return WIFI_ERROR_NONE;
1049 }
1050
1051 EXPORT_API int wifi_ap_get_eap_ca_cert_file(wifi_ap_h ap, char** file)
1052 {
1053         net_profile_info_t *profile_info = NULL;
1054
1055         if (_wifi_libnet_check_ap_validity(ap) == false || file == NULL) {
1056                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1057                 return WIFI_ERROR_INVALID_PARAMETER;
1058         }
1059
1060         profile_info = (net_profile_info_t *)ap;
1061         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1062                 return WIFI_ERROR_INVALID_OPERATION;
1063
1064         *file = g_strdup(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.ca_cert_filename);
1065         if (*file == NULL)
1066                 return WIFI_ERROR_OUT_OF_MEMORY;
1067
1068         return WIFI_ERROR_NONE;
1069 }
1070
1071 EXPORT_API int wifi_ap_set_eap_ca_cert_file(wifi_ap_h ap, const char* file)
1072 {
1073         net_profile_info_t *profile_info = NULL;
1074
1075         if (_wifi_libnet_check_ap_validity(ap) == false || file == NULL) {
1076                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1077                 return WIFI_ERROR_INVALID_PARAMETER;
1078         }
1079
1080         profile_info = (net_profile_info_t *)ap;
1081         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1082                 return WIFI_ERROR_INVALID_OPERATION;
1083
1084         g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.ca_cert_filename,
1085                         file, NETPM_WLAN_CA_CERT_FILENAME_LEN+1);
1086
1087         return WIFI_ERROR_NONE;
1088 }
1089
1090 EXPORT_API int wifi_ap_get_eap_client_cert_file(wifi_ap_h ap, char** file)
1091 {
1092         net_profile_info_t *profile_info = NULL;
1093
1094         if (_wifi_libnet_check_ap_validity(ap) == false || file == NULL) {
1095                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1096                 return WIFI_ERROR_INVALID_PARAMETER;
1097         }
1098
1099         profile_info = (net_profile_info_t *)ap;
1100         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1101                 return WIFI_ERROR_INVALID_OPERATION;
1102
1103         *file = g_strdup(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.client_cert_filename);
1104         if (*file == NULL)
1105                 return WIFI_ERROR_OUT_OF_MEMORY;
1106
1107         return WIFI_ERROR_NONE;
1108 }
1109
1110 EXPORT_API int wifi_ap_set_eap_client_cert_file(wifi_ap_h ap, const char* file)
1111 {
1112         net_profile_info_t *profile_info = NULL;
1113
1114         if (_wifi_libnet_check_ap_validity(ap) == false || file == NULL) {
1115                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1116                 return WIFI_ERROR_INVALID_PARAMETER;
1117         }
1118
1119         profile_info = (net_profile_info_t *)ap;
1120         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1121                 return WIFI_ERROR_INVALID_OPERATION;
1122
1123         g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.client_cert_filename,
1124                         file, NETPM_WLAN_CLIENT_CERT_FILENAME_LEN+1);
1125
1126         return WIFI_ERROR_NONE;
1127 }
1128
1129 EXPORT_API int wifi_ap_get_eap_private_key_file(wifi_ap_h ap, char** file)
1130 {
1131         if (_wifi_libnet_check_ap_validity(ap) == false || file == NULL) {
1132                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1133                 return WIFI_ERROR_INVALID_PARAMETER;
1134         }
1135
1136         net_profile_info_t *profile_info = ap;
1137         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1138                 return WIFI_ERROR_INVALID_OPERATION;
1139
1140         *file = g_strdup(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.private_key_filename);
1141         if (*file == NULL)
1142                 return WIFI_ERROR_OUT_OF_MEMORY;
1143
1144         return WIFI_ERROR_NONE;
1145 }
1146
1147 EXPORT_API int wifi_ap_set_eap_private_key_info(wifi_ap_h ap, const char* file, const char* password)
1148 {
1149         if (_wifi_libnet_check_ap_validity(ap) == false || file == NULL) {
1150                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1151                 return WIFI_ERROR_INVALID_PARAMETER;
1152         }
1153
1154         net_profile_info_t *profile_info = ap;
1155         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1156                 return WIFI_ERROR_INVALID_OPERATION;
1157
1158         g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.private_key_filename,
1159                         file, NETPM_WLAN_PRIVATE_KEY_FILENAME_LEN+1);
1160
1161         if (password) {
1162                 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.private_key_passwd,
1163                                 password, NETPM_WLAN_PRIVATE_KEY_PASSWD_LEN+1);
1164         }
1165
1166         return WIFI_ERROR_NONE;
1167 }
1168
1169 EXPORT_API int wifi_ap_get_eap_type(wifi_ap_h ap, wifi_eap_type_e* type)
1170 {
1171         if (_wifi_libnet_check_ap_validity(ap) == false || type == NULL) {
1172                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1173                 return WIFI_ERROR_INVALID_PARAMETER;
1174         }
1175
1176         net_profile_info_t *profile_info = ap;
1177         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1178                 return WIFI_ERROR_INVALID_OPERATION;
1179
1180         switch (profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_type) {
1181         case WLAN_SEC_EAP_TYPE_PEAP:
1182                 *type = WIFI_EAP_TYPE_PEAP;
1183                 break;
1184         case WLAN_SEC_EAP_TYPE_TLS:
1185                 *type = WIFI_EAP_TYPE_TLS;
1186                 break;
1187         case WLAN_SEC_EAP_TYPE_TTLS:
1188                 *type = WIFI_EAP_TYPE_TTLS;
1189                 break;
1190         case WLAN_SEC_EAP_TYPE_SIM:
1191                 *type = WIFI_EAP_TYPE_SIM;
1192                 break;
1193         case WLAN_SEC_EAP_TYPE_AKA:
1194                 *type = WIFI_EAP_TYPE_AKA;
1195                 break;
1196         default:
1197                 return WIFI_ERROR_OPERATION_FAILED;
1198         }
1199
1200         return WIFI_ERROR_NONE;
1201 }
1202
1203 EXPORT_API int wifi_ap_set_eap_type(wifi_ap_h ap, wifi_eap_type_e type)
1204 {
1205         if (_wifi_libnet_check_ap_validity(ap) == false) {
1206                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1207                 return WIFI_ERROR_INVALID_PARAMETER;
1208         }
1209
1210         net_profile_info_t *profile_info = ap;
1211         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1212                 return WIFI_ERROR_INVALID_OPERATION;
1213
1214         switch (type) {
1215         case WIFI_EAP_TYPE_PEAP:
1216                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_PEAP;
1217                 break;
1218         case WIFI_EAP_TYPE_TLS:
1219                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_TLS;
1220                 break;
1221         case WIFI_EAP_TYPE_TTLS:
1222                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_TTLS;
1223                 break;
1224         case WIFI_EAP_TYPE_SIM:
1225                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_SIM;
1226                 break;
1227         case WIFI_EAP_TYPE_AKA:
1228                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_AKA;
1229                 break;
1230         default:
1231                 return WIFI_ERROR_INVALID_PARAMETER;
1232         }
1233
1234         return WIFI_ERROR_NONE;
1235 }
1236
1237 EXPORT_API int wifi_ap_get_eap_auth_type(wifi_ap_h ap, wifi_eap_auth_type_e* type)
1238 {
1239         if (_wifi_libnet_check_ap_validity(ap) == false || type == NULL) {
1240                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1241                 return WIFI_ERROR_INVALID_PARAMETER;
1242         }
1243
1244         net_profile_info_t *profile_info = ap;
1245         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1246                 return WIFI_ERROR_INVALID_OPERATION;
1247
1248         switch (profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_auth) {
1249         case WLAN_SEC_EAP_AUTH_NONE:
1250                 *type = WIFI_EAP_AUTH_TYPE_NONE;
1251                 break;
1252         case WLAN_SEC_EAP_AUTH_PAP:
1253                 *type = WIFI_EAP_AUTH_TYPE_PAP;
1254                 break;
1255         case WLAN_SEC_EAP_AUTH_MSCHAP:
1256                 *type = WIFI_EAP_AUTH_TYPE_MSCHAP;
1257                 break;
1258         case WLAN_SEC_EAP_AUTH_MSCHAPV2:
1259                 *type = WIFI_EAP_AUTH_TYPE_MSCHAPV2;
1260                 break;
1261         case WLAN_SEC_EAP_AUTH_GTC:
1262                 *type = WIFI_EAP_AUTH_TYPE_GTC;
1263                 break;
1264         case WLAN_SEC_EAP_AUTH_MD5:
1265                 *type = WIFI_EAP_AUTH_TYPE_MD5;
1266                 break;
1267         default:
1268                 return WIFI_ERROR_OPERATION_FAILED;
1269         }
1270
1271         return WIFI_ERROR_NONE;
1272 }
1273
1274 EXPORT_API int wifi_ap_set_eap_auth_type(wifi_ap_h ap, wifi_eap_auth_type_e type)
1275 {
1276         if (_wifi_libnet_check_ap_validity(ap) == false) {
1277                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1278                 return WIFI_ERROR_INVALID_PARAMETER;
1279         }
1280
1281         net_profile_info_t *profile_info = ap;
1282         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1283                 return WIFI_ERROR_INVALID_OPERATION;
1284
1285         switch (type) {
1286         case WIFI_EAP_AUTH_TYPE_NONE:
1287                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_NONE;
1288                 break;
1289         case WIFI_EAP_AUTH_TYPE_PAP:
1290                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_PAP;
1291                 break;
1292         case WIFI_EAP_AUTH_TYPE_MSCHAP:
1293                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_MSCHAP;
1294                 break;
1295         case WIFI_EAP_AUTH_TYPE_MSCHAPV2:
1296                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_MSCHAPV2;
1297                 break;
1298         case WIFI_EAP_AUTH_TYPE_GTC:
1299                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_GTC;
1300                 break;
1301         case WIFI_EAP_AUTH_TYPE_MD5:
1302                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_MD5;
1303                 break;
1304         default:
1305                 return WIFI_ERROR_INVALID_PARAMETER;
1306         }
1307
1308         return WIFI_ERROR_NONE;
1309 }