src/wifi/FNetWifi_WifiUtility.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file        FNetWifi_WifiUtility.cpp
  20  * @brief       This is the implementation file for _WifiUtility class.
  21  */
  22
  23 #include <unique_ptr.h>
  24 #include <FBaseColArrayList.h>
  25 #include <FBaseColAllElementsDeleter.h>
  26 #include <FBaseString.h>
  27 #include <FBaseSysLog.h>
  28 #include <FNetIpAddress.h>
  29 #include <FNetIp4Address.h>
  30 #include <FNetWifiWifiBssInfo.h>
  31 #include <FNetWifiWifiSecurityInfo.h>
  32 #include "FNetWifi_WifiUtility.h"
  33 #include "FNetWifi_WifiBssInfoImpl.h"
  34 #include "FNetWifi_WifiSecurityInfoImpl.h"
  35
  36
  37 using namespace std;
  38 using namespace Tizen::Base;
  39 using namespace Tizen::Base::Collection;
  40 using namespace Tizen::Net;
  41
  42 namespace Tizen {       namespace Net { namespace Wifi {
  43
  44 _WifiUtility::_WifiUtility(void)
  45 {
  46 }
  47
  48 _WifiUtility::~_WifiUtility(void)
  49 {
  50 }
  51
  52 WifiAuthenticationType
  53 _WifiUtility::ConvertAuthType(wifi_security_type_e securityMode, wifi_encryption_type_e encryptionMode)
  54 {
  55         WifiAuthenticationType authenticationType = WIFI_AUTHENTICATION_OPEN;
  56
  57         switch (securityMode)
  58         {
  59         case WIFI_SECURITY_TYPE_NONE:
  60                 authenticationType = WIFI_AUTHENTICATION_OPEN;
  61                 break;
  62
  63         case WIFI_SECURITY_TYPE_WEP:
  64                 authenticationType = WIFI_AUTHENTICATION_SHARED;
  65                 break;
  66
  67         case WIFI_SECURITY_TYPE_EAP:
  68
  69                 if (encryptionMode == WIFI_ENCRYPTION_TYPE_TKIP)
  70                 {
  71                         authenticationType = WIFI_AUTHENTICATION_WPA;
  72                 }
  73                 else if (encryptionMode == WIFI_ENCRYPTION_TYPE_AES
  74                                 || encryptionMode == WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED)
  75                 {
  76                         authenticationType = WIFI_AUTHENTICATION_WPA2;
  77                 }
  78                 break;
  79
  80         case WIFI_SECURITY_TYPE_WPA_PSK:
  81                 if (encryptionMode == WIFI_ENCRYPTION_TYPE_TKIP)
  82                 {
  83                         authenticationType = WIFI_AUTHENTICATION_WPA_PSK;
  84                 }
  85                 else if (encryptionMode == WIFI_ENCRYPTION_TYPE_AES)
  86                 {
  87                         authenticationType = WIFI_AUTHENTICATION_WPA2_PSK;
  88                 }
  89                 else
  90                 {
  91                         authenticationType = WIFI_AUTHENTICATION_WPA_WPA2_MIXED_PSK;
  92                 }
  93                 break;
  94         default:
  95                 break;
  96         }
  97
  98         return authenticationType;
  99 }
 100
 101 wifi_security_type_e
 102 _WifiUtility::ConvertSecurityType(WifiAuthenticationType authMode)
 103 {
 104         wifi_security_type_e authenticationType = WIFI_SECURITY_TYPE_NONE;
 105
 106         switch (authMode)
 107         {
 108         case WIFI_AUTHENTICATION_OPEN:
 109         {
 110                 authenticationType = WIFI_SECURITY_TYPE_NONE;
 111                 break;
 112         }
 113         case WIFI_AUTHENTICATION_SHARED:
 114         {
 115                 authenticationType = WIFI_SECURITY_TYPE_WEP;
 116                 break;
 117         }
 118         case WIFI_AUTHENTICATION_WPA:
 119         case WIFI_AUTHENTICATION_WPA2:
 120         {
 121                 authenticationType = WIFI_SECURITY_TYPE_EAP;
 122                 break;
 123         }
 124         case WIFI_AUTHENTICATION_WPA_PSK:
 125         {
 126                 authenticationType = WIFI_SECURITY_TYPE_WPA_PSK;
 127                 break;
 128         }
 129         case WIFI_AUTHENTICATION_WPA2_PSK:
 130         {
 131                 authenticationType = WIFI_SECURITY_TYPE_WPA_PSK;
 132                 break;
 133         }
 134         default:
 135                 break;
 136         }
 137
 138         return authenticationType;
 139 }
 140
 141 WifiRadioChannel
 142 _WifiUtility::ConvertRadioChannel(int frequency)
 143 {
 144         WifiRadioChannel radioChannel = WIFI_RADIO_CHANNEL_UNKNOWN;
 145
 146         switch (frequency)
 147         {
 148         case 2412:
 149                 radioChannel = WIFI_RADIO_CHANNEL_1;
 150                 break;
 151         case 2417:
 152                 radioChannel = WIFI_RADIO_CHANNEL_2;
 153                 break;
 154         case 2422:
 155                 radioChannel = WIFI_RADIO_CHANNEL_3;
 156                 break;
 157         case 2427:
 158                 radioChannel = WIFI_RADIO_CHANNEL_4;
 159                 break;
 160         case 2432:
 161                 radioChannel = WIFI_RADIO_CHANNEL_5;
 162                 break;
 163         case 2437:
 164                 radioChannel = WIFI_RADIO_CHANNEL_6;
 165                 break;
 166         case 2442:
 167                 radioChannel = WIFI_RADIO_CHANNEL_7;
 168                 break;
 169         case 2447:
 170                 radioChannel = WIFI_RADIO_CHANNEL_8;
 171                 break;
 172         case 2452:
 173                 radioChannel = WIFI_RADIO_CHANNEL_9;
 174                 break;
 175         case 2457:
 176                 radioChannel = WIFI_RADIO_CHANNEL_10;
 177                 break;
 178         case 2462:
 179                 radioChannel = WIFI_RADIO_CHANNEL_11;
 180                 break;
 181         case 2467:
 182                 radioChannel = WIFI_RADIO_CHANNEL_12;
 183                 break;
 184         case 2472:
 185                 radioChannel = WIFI_RADIO_CHANNEL_13;
 186                 break;
 187         case 2484:
 188                 radioChannel = WIFI_RADIO_CHANNEL_14;
 189                 break;
 190         default:
 191                 radioChannel = WIFI_RADIO_CHANNEL_UNKNOWN;
 192                 break;
 193         }
 194
 195         return radioChannel;
 196 }
 197
 198 long
 199 _WifiUtility::ConvertPercentagetoRssiValue(char val)
 200 {
 201         if (val >= 75)
 202         {
 203                 return -55;
 204         }
 205         else if (val > 50)
 206         {
 207                 return -70;
 208         }
 209         else if (val > 25)
 210         {
 211                 return -85;
 212         }
 213         else
 214         {
 215                 return -100;
 216         }
 217 }
 218
 219 long
 220 _WifiUtility::ConvertLeveltoRssiValue(wifi_rssi_level_e val)
 221 {
 222         long rssiValue = 0;
 223         SysLog(NID_NET_WIFI, "Enter: [Rssi Level %d]", val);
 224
 225         switch (val)
 226         {
 227         case WIFI_RSSI_LEVEL_4:
 228                 rssiValue = -55;
 229                 break;
 230         case WIFI_RSSI_LEVEL_3:
 231                 rssiValue = -70;
 232                 break;
 233         case WIFI_RSSI_LEVEL_2:
 234                 rssiValue = -85;
 235                 break;
 236         case WIFI_RSSI_LEVEL_1:
 237                 rssiValue = -100;
 238                 break;
 239         default:
 240                 rssiValue = 0;
 241                 break;
 242         }
 243         SysLog(NID_NET_WIFI, "Exit: [Rssi dbm %ld]", rssiValue);
 244
 245         return rssiValue;
 246 }
 247
 248 WifiEncryptionType
 249 _WifiUtility::ConvertEncryptionType(wifi_encryption_type_e encryptionMode)
 250 {
 251         WifiEncryptionType encryptionType = WIFI_ENCRYPTION_NONE;
 252
 253         switch (encryptionMode)
 254         {
 255         case WIFI_ENCRYPTION_TYPE_NONE:
 256         {
 257                 encryptionType = WIFI_ENCRYPTION_NONE;
 258                 break;
 259         }
 260         case WIFI_ENCRYPTION_TYPE_WEP:
 261         {
 262                 encryptionType = WIFI_ENCRYPTION_WEP;
 263                 break;
 264         }
 265         case WIFI_ENCRYPTION_TYPE_TKIP:
 266         {
 267                 encryptionType = WIFI_ENCRYPTION_TKIP;
 268                 break;
 269         }
 270         case WIFI_ENCRYPTION_TYPE_AES:
 271         {
 272                 encryptionType = WIFI_ENCRYPTION_AES;
 273                 break;
 274         }
 275         case WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED:
 276         {
 277                 encryptionType = WIFI_ENCRYPTION_TKIP_AES_MIXED;
 278                 break;
 279         }
 280         default:
 281                 break;
 282         }
 283
 284         return encryptionType;
 285 }
 286
 287 wifi_encryption_type_e
 288 _WifiUtility::ConvertEncryptionType(WifiEncryptionType encryptionMode)
 289 {
 290         wifi_encryption_type_e encryptionType = WIFI_ENCRYPTION_TYPE_NONE;
 291
 292         switch (encryptionMode)
 293         {
 294         case WIFI_ENCRYPTION_NONE:
 295         {
 296                 encryptionType = WIFI_ENCRYPTION_TYPE_NONE;
 297                 break;
 298         }
 299         case WIFI_ENCRYPTION_WEP:
 300         {
 301                 encryptionType = WIFI_ENCRYPTION_TYPE_WEP;
 302                 break;
 303         }
 304         case WIFI_ENCRYPTION_TKIP:
 305         {
 306                 encryptionType = WIFI_ENCRYPTION_TYPE_TKIP;
 307                 break;
 308         }
 309         case WIFI_ENCRYPTION_AES:
 310         {
 311                 encryptionType = WIFI_ENCRYPTION_TYPE_AES;
 312                 break;
 313         }
 314         case WIFI_ENCRYPTION_TKIP_AES_MIXED:
 315         {
 316                 encryptionType = WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
 317                 break;
 318         }
 319         default:
 320                 break;
 321         }
 322
 323         return encryptionType;
 324 }
 325
 326 WifiEapType
 327 _WifiUtility::ConvertEapType(wifi_eap_type_e eapType, wifi_eap_auth_type_e eapAuthType)
 328 {
 329         WifiEapType eapReturnType = WIFI_EAP_NONE;
 330
 331         switch (eapType)
 332         {
 333         case WIFI_EAP_TYPE_PEAP:
 334                 if (eapAuthType == WIFI_EAP_AUTH_TYPE_MSCHAPV2)
 335                 {
 336                         eapReturnType = WIFI_EAP_PEAP_MSCHAPV2;
 337                 }
 338                 else if(eapAuthType == WIFI_EAP_AUTH_TYPE_GTC)
 339                 {
 340                         eapReturnType = WIFI_EAP_PEAP_GTC;
 341                 }
 342                 else
 343                 {
 344                         SysLog(NID_NET_WIFI,"Not supported EAP authentication type.");
 345                 }
 346                 break;
 347         case WIFI_EAP_TYPE_TLS:
 348                 SysLog(NID_NET_WIFI,"Not supported EAP TLS.");
 349                 break;
 350         case WIFI_EAP_TYPE_TTLS:
 351                 if (eapAuthType == WIFI_EAP_AUTH_TYPE_MSCHAPV2)
 352                 {
 353                         eapReturnType = WIFI_EAP_TTLS_MSCHAPV2;
 354                 }
 355                 else
 356                 {
 357                    SysLog(NID_NET_WIFI,"Not supported EAP authentication type.");
 358                 }
 359                 break;
 360         case WIFI_EAP_TYPE_SIM:
 361                 eapReturnType = WIFI_EAP_SIM;
 362                 break;
 363         case WIFI_EAP_TYPE_AKA:
 364                 eapReturnType = WIFI_EAP_AKA;
 365                 break;
 366         default:
 367                    break;
 368         }
 369
 370         return eapReturnType;
 371 }
 372
 373 wifi_eap_type_e
 374 _WifiUtility::ConvertEapType(WifiEapType eapType)
 375 {
 376         wifi_eap_type_e eapReturnType = WIFI_EAP_TYPE_PEAP;
 377         switch(eapType)
 378         {
 379         case WIFI_EAP_SIM:
 380                 eapReturnType = WIFI_EAP_TYPE_SIM;
 381                 break;
 382         case WIFI_EAP_AKA:
 383                 eapReturnType = WIFI_EAP_TYPE_AKA;
 384                 break;
 385         case WIFI_EAP_TTLS_MSCHAPV2:
 386                 eapReturnType = WIFI_EAP_TYPE_TTLS;
 387                 break;
 388         case WIFI_EAP_PEAP_MSCHAPV2:
 389                 eapReturnType = WIFI_EAP_TYPE_PEAP;
 390                 break;
 391         case WIFI_EAP_PEAP_GTC:
 392                 eapReturnType = WIFI_EAP_TYPE_PEAP;
 393                 break;
 394         case WIFI_EAP_TLS:
 395                 eapReturnType = WIFI_EAP_TYPE_TLS;
 396                 break;
 397         default:
 398                 break;
 399         }
 400
 401         return eapReturnType;
 402 }
 403
 404 wifi_eap_auth_type_e
 405 _WifiUtility::ConvertEapAuthType(WifiEapType eapType)
 406 {
 407         wifi_eap_auth_type_e eapAuthType = WIFI_EAP_AUTH_TYPE_NONE;
 408         switch(eapType)
 409         {
 410         case WIFI_EAP_SIM:
 411                 eapAuthType = WIFI_EAP_AUTH_TYPE_NONE;
 412                 break;
 413         case WIFI_EAP_AKA:
 414                 eapAuthType = WIFI_EAP_AUTH_TYPE_NONE;
 415                 break;
 416         case WIFI_EAP_TTLS_MSCHAPV2:
 417                 eapAuthType = WIFI_EAP_AUTH_TYPE_MSCHAPV2;
 418                 break;
 419         case WIFI_EAP_PEAP_MSCHAPV2:
 420                 eapAuthType = WIFI_EAP_AUTH_TYPE_MSCHAPV2;
 421                 break;
 422         case WIFI_EAP_PEAP_GTC:
 423                 eapAuthType = WIFI_EAP_AUTH_TYPE_GTC;
 424                 break;
 425         case WIFI_EAP_TLS:
 426                 eapAuthType = WIFI_EAP_AUTH_TYPE_NONE;
 427                 break;
 428         default:
 429                 break;
 430         }
 431         return eapAuthType;
 432 }
 433
 434 String
 435 _WifiUtility::ConvertMacAddress(char macAddress[])
 436 {
 437         static  const int MAX_MAC_ADDRESS_LENGTH = 17;
 438         String convertMacAddress;
 439
 440         for (int  i = 0; i < MAX_MAC_ADDRESS_LENGTH; i++)
 441         {
 442                 if (macAddress[i] == ':')
 443                 {
 444                         convertMacAddress.Append('-');
 445                 }
 446                 else
 447                 {
 448                         convertMacAddress.Append(macAddress[i]);
 449                 }
 450         }
 451
 452         return convertMacAddress;
 453 }
 454
 455 String
 456 _WifiUtility::GetBssIdFromApHandle(wifi_ap_h pApHandle)
 457 {
 458         char* pBssid = null;
 459         int error = wifi_ap_get_bssid(pApHandle, &pBssid);
 460         SysTryReturn(NID_NET_WIFI, error == WIFI_ERROR_NONE && pBssid != null, String(), E_OPERATION_FAILED,
 461                 "[E_OPERATION_FAILED] Getting the BSSID of the AP has failed. [0x%08X].", error);
 462
 463         String bssId(pBssid);
 464         free(pBssid);
 465
 466         return bssId;
 467 }
 468
 469 WifiBssInfo*
 470 _WifiUtility::CreateWifiBssInfoInstanceN(wifi_ap_h& pApHandle)
 471 {
 472         unique_ptr<WifiBssInfo> pBssInfo;
 473         _WifiBssInfoImpl* pBssInfoImpl = null;
 474         result r = E_SUCCESS;
 475         int apRes = WIFI_ERROR_NONE;
 476
 477         WifiSecurityInfo secuInfo;
 478         _WifiSecurityInfoImpl* pSecuInfoImpl = null;
 479
 480         wifi_ip_config_type_e ipType = WIFI_IP_CONFIG_TYPE_NONE;
 481         NetAddressScheme netIpScheme = NET_ADDRESS_SCHEME_NONE;
 482         char* pAddrStr = null;
 483         unique_ptr<IpAddress> pAddress;
 484         wifi_proxy_type_e proxyType = WIFI_PROXY_TYPE_DIRECT;
 485         NetProxyType netProxyType = NET_PROXY_TYPE_NONE;
 486
 487         pBssInfo.reset(_WifiBssInfoImpl::CreateWifiBssInfoN());
 488         SysTryReturn(NID_NET_WIFI, pBssInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 489
 490         pBssInfoImpl = _WifiBssInfoImpl::GetInstance(*pBssInfo);
 491         pBssInfoImpl->SetBssHandle(pApHandle);
 492
 493         // SSID
 494         char* pSsid = null;
 495         apRes = wifi_ap_get_essid(pApHandle, &pSsid);
 496         SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE, null, E_OPERATION_FAILED,
 497                         "[E_OPERATION_FAILED] Getting the SSID of the AP has failed. [0x%08X].", apRes);
 498         pBssInfoImpl->SetSsid(String(pSsid));
 499         free(pSsid);
 500
 501         // BSSID
 502         char* pBssid = null;
 503         apRes = wifi_ap_get_bssid(pApHandle, &pBssid);
 504         SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE, null, E_OPERATION_FAILED,
 505                         "[E_OPERATION_FAILED] Getting the BSSID of the AP has failed. [0x%08X].", apRes);
 506         pBssInfoImpl->SetBssId(ConvertMacAddress(pBssid));
 507         free(pBssid);
 508
 509         // Security type - Authentication type & Encryption type
 510         wifi_security_type_e secType;
 511         apRes = wifi_ap_get_security_type(pApHandle, &secType);
 512         SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE, null, E_OPERATION_FAILED,
 513                         "[E_OPERATION_FAILED] Getting the security type of the AP has failed. [0x%08X].", apRes);
 514
 515         wifi_encryption_type_e encType;
 516         apRes = wifi_ap_get_encryption_type(pApHandle, &encType);
 517         SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE, null, E_OPERATION_FAILED,
 518                         "[E_OPERATION_FAILED] Getting the encryption type of the AP has failed. [0x%08X].", apRes);
 519
 520         SysLog(NID_NET_WIFI, "SSID : %ls security type : %d encryption type : %d", pBssInfoImpl->GetSsid().GetPointer(), secType, encType);
 521
 522         pSecuInfoImpl = _WifiSecurityInfoImpl::GetInstance(secuInfo);
 523         pSecuInfoImpl->SetAuthenticationType(ConvertAuthType(secType, encType));
 524         pSecuInfoImpl->SetEncryptionType(ConvertEncryptionType(encType));
 525         pBssInfoImpl->SetSecurityInfo(secuInfo);
 526
 527         // BSS Type
 528         pBssInfoImpl->SetBssType(WIFI_BSS_TYPE_INFRASTRUCTURE);
 529
 530         // Radio Channel
 531         int frequency = -1;
 532         apRes = wifi_ap_get_frequency(pApHandle, &frequency);
 533         SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE, null, E_OPERATION_FAILED,
 534                         "[E_OPERATION_FAILED] Getting the frequency band of the AP has failed. [0x%08X].", apRes);
 535         pBssInfoImpl->SetRadioChannel(ConvertRadioChannel(frequency));
 536
 537         // RSSI
 538         int rssi = -1;
 539         apRes = wifi_ap_get_rssi(pApHandle, &rssi);
 540         SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE, null, E_OPERATION_FAILED,
 541                         "[E_OPERATION_FAILED] Getting the RSSI value of the AP has failed. [0x%08X].", apRes);
 542         pBssInfoImpl->SetRssi(ConvertPercentagetoRssiValue(rssi));
 543
 544         // Data Rate
 545         int dataRate = -1;
 546         apRes = wifi_ap_get_max_speed(pApHandle, &dataRate);
 547         SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE, null, E_OPERATION_FAILED,
 548                         "[E_OPERATION_FAILED] Getting the MAX speed of the AP has failed. [0x%08X].", apRes);
 549         pBssInfoImpl->SetDataRate(dataRate);
 550
 551         // Known.
 552         bool isKnown = false;
 553         apRes = wifi_ap_is_favorite(pApHandle, &isKnown);
 554         SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE, null, E_OPERATION_FAILED,
 555                         "[E_OPERATION_FAILED] Checking the AP is a known device has failed. [0x%08X].", apRes);
 556         pBssInfoImpl->SetKnown(isKnown);
 557
 558         // IP Address Scheme. Only IPv4 as the address family is taken into consideration for now.
 559         apRes = wifi_ap_get_ip_config_type(pApHandle, WIFI_ADDRESS_FAMILY_IPV4, &ipType);
 560         SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE && ipType != WIFI_IP_CONFIG_TYPE_NONE, null, E_OPERATION_FAILED,
 561                         "[E_OPERATION_FAILED] Getting the IP address scheme to AP has failed. [0x%08X].", apRes);
 562         netIpScheme = (ipType == WIFI_IP_CONFIG_TYPE_STATIC) ? NET_ADDRESS_SCHEME_STATIC : NET_ADDRESS_SCHEME_DYNAMIC;
 563         pBssInfoImpl->SetLocalAddressScheme(netIpScheme);
 564
 565         if (netIpScheme == NET_ADDRESS_SCHEME_STATIC)
 566         {
 567                 // IP Address. Only IPv4 as the address family is taken into consideration for now.
 568                 apRes = wifi_ap_get_ip_address(pApHandle, WIFI_ADDRESS_FAMILY_IPV4, &pAddrStr);
 569                 SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE, null, E_OPERATION_FAILED,
 570                                 "[E_OPERATION_FAILED] Getting the IP address to AP has failed. [0x%08X].", apRes);
 571                 pAddress.reset(new (std::nothrow) Ip4Address(String(pAddrStr)));
 572                 r = GetLastResult();
 573                 free(pAddrStr);
 574                 SysTryReturn(NID_NET_WIFI, pAddress != null && r == E_SUCCESS, null, E_OPERATION_FAILED,
 575                                 "[E_OPERATION_FAILED] Creating an Ip4Address instance has faield. (from [%s])", GetErrorMessage(r));
 576                 pBssInfoImpl->SetLocalAddress(pAddress.release()); // ignore result
 577
 578                 // Subnet Mask. Only IPv4 as the address family is taken into consideration for now.
 579                 apRes = wifi_ap_get_subnet_mask(pApHandle, WIFI_ADDRESS_FAMILY_IPV4, &pAddrStr);
 580                 SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE, null, E_OPERATION_FAILED,
 581                                 "[E_OPERATION_FAILED] Getting the subnet mask to AP has failed. [0x%08X].", apRes);
 582                 pAddress.reset(new (std::nothrow) Ip4Address(String(pAddrStr)));
 583                 r = GetLastResult();
 584                 free(pAddrStr);
 585                 SysTryReturn(NID_NET_WIFI, pAddress != null && r == E_SUCCESS, null, E_OPERATION_FAILED,
 586                                 "[E_OPERATION_FAILED] Creating an Ip4Address instance has faield. (from [%s])", GetErrorMessage(r));
 587                 pBssInfoImpl->SetSubnetMaskAddress(pAddress.release()); // ignore result
 588
 589                 // Default Gateway Address. Only IPv4 as the address family is taken into consideration for now.
 590                 apRes = wifi_ap_get_gateway_address(pApHandle, WIFI_ADDRESS_FAMILY_IPV4, &pAddrStr);
 591                 SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE, null, E_OPERATION_FAILED,
 592                                 "[E_OPERATION_FAILED] Getting the default gateway address to AP has failed. [0x%08X].", apRes);
 593                 pAddress.reset(new (std::nothrow) Ip4Address(String(pAddrStr)));
 594                 r = GetLastResult();
 595                 free(pAddrStr);
 596                 SysTryReturn(NID_NET_WIFI, pAddress != null && r == E_SUCCESS, null, E_OPERATION_FAILED,
 597                                 "[E_OPERATION_FAILED] Creating an Ip4Address instance has faield. (from [%s])", GetErrorMessage(r));
 598                 pBssInfoImpl->SetDefaultGatewayAddress(pAddress.release()); // ignore result
 599
 600                 // Primary DNS Address. Only IPv4 as the address family is taken into consideration for now.
 601                 apRes = wifi_ap_get_dns_address(pApHandle, 1, WIFI_ADDRESS_FAMILY_IPV4, &pAddrStr);
 602                 SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE, null, E_OPERATION_FAILED,
 603                                 "[E_OPERATION_FAILED] Getting the primary DNS address to AP has failed. [0x%08X].", apRes);
 604                 pAddress.reset(new (std::nothrow) Ip4Address(String(pAddrStr)));
 605                 r = GetLastResult();
 606                 free(pAddrStr);
 607                 SysTryReturn(NID_NET_WIFI, pAddress != null && r == E_SUCCESS, null, E_OPERATION_FAILED,
 608                                 "[E_OPERATION_FAILED] Creating an Ip4Address instance has faield. (from [%s])", GetErrorMessage(r));
 609                 pBssInfoImpl->SetPrimaryDnsAddress(pAddress.release()); // ignore result
 610
 611                 // Secondary DNS Address. Only IPv4 as the address family is taken into consideration for now.
 612                 apRes = wifi_ap_get_dns_address(pApHandle, 2, WIFI_ADDRESS_FAMILY_IPV4, &pAddrStr);
 613                 SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE, null, E_OPERATION_FAILED,
 614                                 "[E_OPERATION_FAILED] Getting the secondary DNS address to AP has failed. [0x%08X].", apRes);
 615                 pAddress.reset(new (std::nothrow) Ip4Address(String(pAddrStr)));
 616                 r = GetLastResult();
 617                 free(pAddrStr);
 618                 SysTryReturn(NID_NET_WIFI, pAddress != null && r == E_SUCCESS, null, E_OPERATION_FAILED,
 619                                 "[E_OPERATION_FAILED] Creating an Ip4Address instance has faield. (from [%s])", GetErrorMessage(r));
 620                 pBssInfoImpl->SetSecondaryDnsAddress(pAddress.release()); // ignore result
 621         }
 622
 623         // Proxy Type.
 624         apRes = wifi_ap_get_proxy_type(pApHandle, &proxyType);
 625         SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE, null, E_OPERATION_FAILED,
 626                         "[E_OPERATION_FAILED] Getting the proxy type to AP has failed. [0x%08X].", apRes);
 627         netProxyType = (proxyType == WIFI_PROXY_TYPE_MANUAL) ? NET_PROXY_TYPE_MANUAL : NET_PROXY_TYPE_NONE;
 628         pBssInfoImpl->SetProxyType(netProxyType);
 629
 630         if (netProxyType != NET_PROXY_TYPE_NONE)
 631         {
 632                 // Proxy Address. Only IPv4 as the address family is taken into consideration for now.
 633                 apRes = wifi_ap_get_proxy_address(pApHandle, WIFI_ADDRESS_FAMILY_IPV4, &pAddrStr);
 634                 SysTryReturn(NID_NET_WIFI, apRes == WIFI_ERROR_NONE, null, E_OPERATION_FAILED,
 635                                 "[E_OPERATION_FAILED] Getting the proxy address to AP has failed. [0x%08X].", apRes);
 636                 pBssInfoImpl->SetProxyAddress(String(pAddrStr)); // ignore result
 637                 free(pAddrStr);
 638         }
 639
 640         return pBssInfo.release();
 641 }
 642
 643 void
 644 _WifiUtility::WifiApClone(void*& pDestHandle, void* pSrcHandle)
 645 {
 646         wifi_ap_h& pDestAp = static_cast<wifi_ap_h&>(pDestHandle);
 647         wifi_ap_h pSrcAp = static_cast<wifi_ap_h>(pSrcHandle);
 648         wifi_ap_clone(&pDestAp, pSrcAp);
 649 }
 650
 651 void
 652 _WifiUtility::WifiApDestory(void*& pApApHandler)
 653 {
 654         wifi_ap_destroy(pApApHandler);
 655         pApApHandler = null;
 656 }
 657
 658 bool
 659 _WifiUtility::CheckAddressEquality(Tizen::Net::IpAddress* pFirstAddress, Tizen::Net::IpAddress* pSecondAddress)
 660 {
 661         if (pFirstAddress == null && pSecondAddress == null)
 662         {
 663                 SysLog(NID_NET_WIFI, "if (pFirstAddress == null && pSecondAddress == null) true");
 664                 return true;
 665         }
 666         else if(pFirstAddress == null && pSecondAddress != null)
 667         {
 668                 SysLog(NID_NET_WIFI, "if (pFirstAddress == null && pSecondAddress == null) false");
 669                 return false;
 670         }
 671         else if(pFirstAddress != null && pSecondAddress == null)
 672         {
 673                 SysLog(NID_NET_WIFI, "if (pFirstAddress == null && pSecondAddress == null) false");
 674                 return false;
 675         }
 676
 677         return pFirstAddress->Equals(*pSecondAddress);
 678 }
 679
 680 Tizen::Base::Collection::IList*
 681 _WifiUtility::GetWifiBssInfoListCloneN(const Tizen::Base::Collection::IList* pSrcList)
 682 {
 683         result r = E_SUCCESS;
 684         unique_ptr<ArrayList, AllElementsDeleter> pDescList;
 685         int count = 0;
 686
 687         SysTryReturn(NID_NET_WIFI, pSrcList != null, null, E_FAILURE, "[E_FAILURE] Failed to get the BSS info list.");
 688
 689         count = pSrcList->GetCount();
 690
 691         pDescList.reset(new (std::nothrow) ArrayList(SingleObjectDeleter));
 692         SysTryReturn(NID_NET_WIFI, pDescList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 693
 694         r = pDescList->Construct(count);
 695         r = TransExceptionsExclusive(r, E_FAILURE, E_OUT_OF_MEMORY);
 696         SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Failed to construct a new BSS info list.", GetErrorMessage(r));
 697
 698         for (int i = 0; i < count; i++)
 699         {
 700                 const WifiBssInfo* pSrcBssInfo = dynamic_cast<const WifiBssInfo*>(pSrcList->GetAt(i));
 701                 SysTryReturn(NID_NET_WIFI, pSrcBssInfo != null, null, E_FAILURE, "[E_FAILURE] Failed to get the BSS Info for the list.");
 702
 703                 WifiBssInfo* pDescBssInfo = new (std::nothrow) WifiBssInfo(*pSrcBssInfo);
 704                 SysTryReturn(NID_NET_WIFI, pDescBssInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 705
 706                 r = pDescList->Add(*pDescBssInfo);
 707                 r = TransExceptionsExclusive(r, E_FAILURE, E_OUT_OF_MEMORY);
 708                 SysTryReturn(NID_NET_WIFI, r == E_SUCCESS, null, r, "[%s] Failed to add a new BSS info to the list.", GetErrorMessage(r));
 709         }
 710
 711         return pDescList.release();
 712 }
 713
 714 } } } // Tizen::Net::Wifi