/*
* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Class to dig information of scan results.
*
*/


#include "genscaninfo.h"
#include "genscaninfoie.h"

// Default values for information element IDs.
const u8_t WPA_IE_ID              = 221;
const u8_t SCAN_WPA_OUI_LENGTH    = 4;
const u8_t SCAN_WPA_OUI[]         = { 0x00, 0x50, 0xF2, 0x01 };
const u8_t SCAN_WSC_OUI[]         = { 0x00, 0x50, 0xF2, 0x04 };

const u8_t SCAN_OUI_TYPE_OFFSET = 3;
const u8_t SCAN_OUI_SUBTYPE_OFFSET = 4;

/** Offset from AttributeType field to DataLength field */
const u8_t SCAN_WSC_IE_DATA_LENGTH_OFFSET = 2;

/** Offset from AttributeType field to Data field */
const u8_t SCAN_WSC_IE_DATA_AREA_OFFSET = 4;

/** Offset to first Protected Setup attribute type in IE */
const u8_t SCAN_WSC_IE_PROTECTED_SETUP_DATA_OFFSET = 2+4;

/** IDs for different data elements in WSC IE. */
const u16_t SCAN_WSC_IE_AP_SETUP_LOCKED       = 0x1057;

// ================= MEMBER FUNCTIONS =======================

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
ScanInfo::ScanInfo( const ScanList& scan_list ) :
    ScanListIterator( scan_list ), 
    ie_iter_m( current_m + MGMT_BODY_OFFSET )
    {
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
WlanSecurityMode ScanInfo::SecurityMode()
    {
    ScanInfoIe ie;
    return ie.SecurityMode( *this );
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
WlanScanError ScanInfo::InformationElement(
    u8_t ie_id, 
    u8_t& ie_length, 
    const u8_t** ie_data )
    {
    // IE is not found when the whole scan info element is gone through.
    //
    // The Element format is:
    // +----+----+--...--+
    // | a  | b  | c     |
    // +----+----+--...--+
    // where
    // a) Element ID (1 byte)
    // b) Length (1 byte)
    // c) Information (length bytes)
    //

    u8_t ie, len;
    const u8_t* data;

    if ( FirstIE( ie, len, &data ) != WlanScanError_Ok )
        {
        ie_length = 0;
        *ie_data = NULL;
        return WlanScanError_IeNotFound;
        }

    WlanScanError ret( WlanScanError_Ok );

    while ( ie != ie_id && ret == WlanScanError_Ok )
        {
        ret = NextIE( ie, len, &data );
        }

    ie_length = len;
    *ie_data = data;
    return ret;
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
WlanScanError ScanInfo::WpaIE(
    u8_t& ie_length, 
    const u8_t** ie_data )
    {
    // Element format is:
    // +----+-----+-----+-----+------+-------+--...--+-------+--...--+--------+
    // | ID | Len | OUI | Ver | GKCS | PKCSC | PKSCL | AKMSC | AKMSL | RSNCap |
    // +----+-----+-----+-----+------+-------+--...--+-------+--...--+--------+
    // where
    // ID     = Element ID = 221 (1 octet)
    // Len    = Length (1 octet)
    // OUI    = 00:50:F2:01 (4 octets)
    // Ver    = Version (2 octets)
    // GKCS   = Group Key Cipher Suite (4 octets)
    // PKCSC  = Pairwise Key Cipher Suite Count (2 octets)
    // PKCSL  = Pairwise Key Cipher Suite List (4*m octets)
    // AKMSC  = Authenticated Key Management Suite Count (2 octets)
    // AKMSL  = Authenticated Key Management Suite List (4*n octets)
    // RSNCap = RSN Capabilities

    u8_t ie( WPA_IE_ID ), len;
    const u8_t* data;

    // Find out the first element
    if ( InformationElement( WPA_IE_ID, len, &data ) != WlanScanError_Ok )
        { // Okay, it didn't exist.
        ie_length = 0;
        *ie_data = NULL;
        return WlanScanError_IeNotFound;
        }

    // The ID is correct but check also the UID.
    WlanScanError ret( WlanScanError_Ok );

    while ( ret == WlanScanError_Ok &&
            ( ie != WPA_IE_ID ||
              len < SCAN_WPA_OUI_LENGTH ||
              !( data[0] == SCAN_WPA_OUI[0] && data[1] == SCAN_WPA_OUI[1] &&
                 data[2] == SCAN_WPA_OUI[2] && data[3] == SCAN_WPA_OUI[3] ) ) )
        {
        ret = NextIE( ie, len, &data );
        }

    // Check is the element was corrupted
    if ( ie != WPA_IE_ID )
        {
        ie_length = 0;
        *ie_data = NULL;
        return WlanScanError_IeNotFound;
        }

    ie_length = len;
    *ie_data = data;
    return ret;
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
WlanScanError ScanInfo::InformationElement(
    u8_t ie_id,
    const WlanIeOui& ie_oui,
    u8_t ie_oui_type,
    u8_t& ie_length, 
    const u8_t** ie_data )
    {
    // Element format is:
    // +----+-----+-----+-----+------+-------+--...--+-------+--...--+--------+
    // | ID | Len | OUI |     |      |       |       |       |       |        |
    // +----+-----+-----+-----+------+-------+--...--+-------+--...--+--------+
    // where
    // ID     = Element ID (1 octet)
    // Len    = Length (1 octet)
    // OUI    = OUI (3 octets)
    // OUItyp = OUI Type (1 octet)

    u8_t ie( ie_id ); 
    u8_t len( 0 );
    const u8_t* data;

    // Find the first element
    if ( InformationElement( ie_id, len, &data ) 
         != WlanScanError_Ok )
        { // Okay, it didn't exist.
        ie_length = 0;
        *ie_data = NULL;
        return WlanScanError_IeNotFound;
        }

    // The ID is correct but also the OUI and OUI Type need to match
    WlanScanError ret( WlanScanError_Ok );

    while ( ret == WlanScanError_Ok && 
            ( ie != ie_id || 
              !( data[0] == ie_oui[0] && 
                 data[1] == ie_oui[1] &&
                 data[2] == ie_oui[2] 
               ) ||
              *( data + SCAN_OUI_TYPE_OFFSET ) != ie_oui_type
            ) 
          )
        {
        ret = NextIE( ie, len, &data );
        }

    // Check if the element is corrupted
    if ( ie != ie_id )
        {
        ie_length = 0;
        *ie_data = NULL;
        return WlanScanError_IeNotFound;
        }

    ie_length = len;
    *ie_data = data;
    return ret;
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
WlanScanError ScanInfo::InformationElement(
    u8_t ie_id,
    const WlanIeOui& ie_oui,
    u8_t ie_oui_type,
    u8_t ie_oui_subtype,
    u8_t& ie_length, 
    const u8_t** ie_data )
    {
    // Element format is:
    // +----+-----+-----+-----+------+-------+--...--+-------+--...--+--------+
    // | ID | Len | OUI |     |      |       |       |       |       |        |
    // +----+-----+-----+-----+------+-------+--...--+-------+--...--+--------+
    // where
    // ID     = Element ID (1 octet)
    // Len    = Length (1 octet)
    // OUI    = OUI (3 octets)
    // OUItyp = OUI Type (1 octet)

    u8_t ie( ie_id ); 
    u8_t len( 0 );
    const u8_t* data;

    // Find the first element
    if ( InformationElement( ie_id, len, &data ) 
         != WlanScanError_Ok )
        { // Okay, it didn't exist.
        ie_length = 0;
        *ie_data = NULL;
        return WlanScanError_IeNotFound;
        }

    // The ID is correct but also the OUI and OUI Type need to match
    WlanScanError ret( WlanScanError_Ok );

    while ( ret == WlanScanError_Ok && 
            ( ie != ie_id || 
              !( data[0] == ie_oui[0] && 
                 data[1] == ie_oui[1] &&
                 data[2] == ie_oui[2] 
               ) ||
              *( data + SCAN_OUI_TYPE_OFFSET ) != ie_oui_type ||
              *( data + SCAN_OUI_SUBTYPE_OFFSET ) != ie_oui_subtype              
            ) 
          )
        {
        ret = NextIE( ie, len, &data );
        }

    // Check if the element is corrupted
    if ( ie != ie_id )
        {
        ie_length = 0;
        *ie_data = NULL;
        return WlanScanError_IeNotFound;
        }

    ie_length = len;
    *ie_data = data;
    return ret;
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
WlanScanError ScanInfo::FirstIE( 
    u8_t& ie_id, 
    u8_t& ie_length, 
    const u8_t** ie_data )
    {
    if( !current_m )
        {
        return WlanScanError_IeNotFound;
        }
    ie_iter_m = current_m + MGMT_BODY_OFFSET;
    return CurrentIE( ie_id, ie_length, ie_data );
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
WlanScanError ScanInfo::NextIE(
    u8_t& ie_id, 
    u8_t& ie_length, 
    const u8_t** ie_data )
    {
    if( !current_m )
        {
        return WlanScanError_IeNotFound;
        }
    ie_iter_m += *( ie_iter_m + 1 ) + 2;
    return CurrentIE( ie_id, ie_length, ie_data );
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
WlanScanError ScanInfo::CurrentIE(
    u8_t& ie_id, 
    u8_t& ie_length, 
    const u8_t** ie_data ) const
    {
    if ( !current_m || ie_iter_m >= current_m + Size() )
        {
        ie_id = 0;
        ie_length = 0;
        *ie_data = NULL;
        return WlanScanError_IeNotFound;
        }

    ie_id = *ie_iter_m;
    ie_length = *( ie_iter_m+1 );
    *ie_data = ie_iter_m+2;
    return WlanScanError_Ok;
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
bool_t ScanInfo::IsProtectedSetupSupported()
    {
    u8_t ie_length = 0;
    const u8_t* ie_data = NULL;
    const WlanIeOui ie_oui = { SCAN_WSC_OUI[0], SCAN_WSC_OUI[1], SCAN_WSC_OUI[2] };
    const u8_t ie_oui_type = SCAN_WSC_OUI[3];
    
    WlanScanError err = InformationElement( WPA_IE_ID,
                                            ie_oui, ie_oui_type,
                                            ie_length, &ie_data );
    
    if (err == WlanScanError_IeNotFound
        || ie_data == NULL 
        || ie_length == 0 )
        {
        return false_t;
        }
    
    // WSC IE is found, next check whether AP setup is locked (locked state would prevent use of Protected Setup)
    return !IsApSetupLocked( ie_data, ie_length );
    }


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
bool_t ScanInfo::IsApSetupLocked(
    const u8_t* ie_data,
    const u8_t ie_length ) const
    {
    u16_t index( SCAN_WSC_IE_PROTECTED_SETUP_DATA_OFFSET );
    
    while ( (index + SCAN_WSC_IE_DATA_LENGTH_OFFSET + 1) < ie_length)
        {
        // Make big endian to little endian conversion.
        u16_t attribute_type = (ie_data[index]<<8) 
                             | (ie_data[index+1]);
        
        u16_t attribute_data_length = (ie_data[index + SCAN_WSC_IE_DATA_LENGTH_OFFSET]<<8) 
                                    | (ie_data[index + SCAN_WSC_IE_DATA_LENGTH_OFFSET+1]);
        
        // Check if all attribute data does not fit current IE.
        if ( ( index + attribute_data_length + SCAN_WSC_IE_DATA_AREA_OFFSET ) > ie_length)
            {
            // attribute does not fit current IE
            return false_t;
            }
            
        if (attribute_type == SCAN_WSC_IE_AP_SETUP_LOCKED)
            {
            // AP setup locked attribute found, return its value.
            return ie_data[index + SCAN_WSC_IE_DATA_AREA_OFFSET];
            }
        
        // update index to start of next attribute
        index += SCAN_WSC_IE_DATA_AREA_OFFSET + attribute_data_length;
        }
    // 
    return false_t;
    }