/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:    Defines a class, which holds physical proxy information.

*

*/

// INCLUDE FILES

#include "CWPAPPhysicalProxy.h"				// Own header

#include <CWPCharacteristic.h>

#include <CWPParameter.h>

#include <WPAdapterUtil.h>

#include <featmgr.h>

#include "CWPAPLogicalProxy.h"

#include "CWPAPPort.h"

#include "CWPAPNapdef.h"

#include "WPAPAdapter.pan"

#include "CWPLog.h"

#include "WPAPDefs.h"

#include <cmconnectionmethodext.h>

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

// -----------------------------------------------------------------------------

// CWPAPPhysicalProxy::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CWPAPPhysicalProxy* CWPAPPhysicalProxy::NewLC( 

                                            const TDesC& aDefaultName, 

                                            CWPCharacteristic& aCharacteristic, 

    CWPCharacteristic& aLogicalCharacteristic,

    CWPAPPort*& aPort )

	{

	CWPAPPhysicalProxy* self = new(ELeave) CWPAPPhysicalProxy( 

	                                                    aDefaultName, 

                                                        aLogicalCharacteristic,

                                                        aPort ); 

	CleanupStack::PushL( self );

	self->ConstructL();

    aCharacteristic.AcceptL( *self );

	return self;

	}

// -----------------------------------------------------------------------------

// Destructor

// -----------------------------------------------------------------------------

//

CWPAPPhysicalProxy::~CWPAPPhysicalProxy()

	{

	delete iPort;

    iNapdefs.ResetAndDestroy();

    iNapdefs.Close();

	}

// -----------------------------------------------------------------------------

// CWPAPPhysicalProxy::ValidateL

// -----------------------------------------------------------------------------

//

TBool CWPAPPhysicalProxy::ValidateL()

	{

	TBool isValid( EFalse );

	// We must have proxy address otherwise this proxy isn't valid.

	if ( iProxyAddr )

		{

		switch ( iPxAddrType )

			{

			case EPxAddrTypeIPv4:

				{

				isValid = WPAdapterUtil::CheckIPv4( iProxyAddr->Value() );

				break;

				}

            case EPxAddrTypeIPv6:

                {

                isValid = FeatureManager::FeatureSupported( KFeatureIdIPv6 )

                    && WPAdapterUtil::CheckIPv6( iProxyAddr->Value() );

                break;

                }

			case EPxAddrTypeUnsupported:

				{

				isValid = EFalse;

				break;

				}

			default: // default value is assumed to be EPxAddrTypeIPv4

				{

				isValid = WPAdapterUtil::CheckIPv4( iProxyAddr->Value() );

				}

			}

		}

	return isValid;

	}

// -----------------------------------------------------------------------------

// CWPAPPhysicalProxy::AddDataL

// -----------------------------------------------------------------------------

//

void CWPAPPhysicalProxy::AddDataL( RCmConnectionMethodExt& aCmItem )

	{  

	LOG("--CWPAP CWPAPPhysicalProxy::AddDataL begin--");	

	TInt err(KErrNone);

	// CMManager

	aCmItem.SetStringAttributeL( CMManager::ECmWapIPGatewayAddress, iProxyAddr->Value());

	LOG2("CWPAP EApWapStartPage, value: %S, err: %d",

	                                             &iProxyAddr->Value(), err);

	//CMManager

	aCmItem.SetStringAttributeL( CMManager::ECmIPGateway, iProxyAddr->Value());

	LOG2("CWPAP EApIspIPGateway, value: %S, err: %d",

	                                             &iProxyAddr->Value(), err);

	//CMManager 

	aCmItem.SetStringAttributeL( CMManager::ECmProxyServerName, iProxyAddr->Value() );

	LOG2("CWPAP EApProxyServerAddress, value: %S, err: %d",

	                                                &iProxyAddr->Value(), err);

	// Store port data

	if ( iPort )

        {

        iPort->AddDataL( aCmItem );

        }

    if ( iLogicalPort)

        {

        iLogicalPort->AddDataL( aCmItem );

        }

    if ( err ) err = 0; // prevent compiler warning

	LOG("--CWPAP CWPAPPhysicalProxy::AddDataL end--");	

	}

// -----------------------------------------------------------------------------

// CWPAPPhysicalProxy::AddItemsL

// -----------------------------------------------------------------------------

//

TInt CWPAPPhysicalProxy::AddItemsL( RPointerArray<CWPAPAccesspointItem>& aItems,

                                    CWPAPItemBase* iLogicalProxy, 

                                    CWPAPItemBase* /*iPhysicalProxy*/ ) 

	{

    TInt count( 0 );

    for( TInt i( 0 ); i < iNapdefs.Count(); i++ )

        {

        CWPAPNapdef* pp = iNapdefs[ i ];

        if( pp->ValidateL() )

            {

            count += pp->AddItemsL( aItems, iLogicalProxy, this );

            }

        }

    return count;

    }

// -----------------------------------------------------------------------------

// CWPAPPhysicalProxy::Name

// -----------------------------------------------------------------------------

//

const TDesC& CWPAPPhysicalProxy::Name()

	{

    if( iName )

        {

        return iName->Value();

        }

    else 

        {

        return KNullDesC;

        }

	}

// -----------------------------------------------------------------------------

// CWPAPPhysicalProxy::VisitL

// -----------------------------------------------------------------------------

//

void CWPAPPhysicalProxy::VisitL( CWPCharacteristic& aCharacteristic )

	{

	TInt type = aCharacteristic.Type();

	// Accept only KWPPort characteristics

	// One valid port is enough for us

	if ( type == KWPPort && !iPort )

		{

        CWPAPPort* port = CWPAPPort::NewLC( aCharacteristic );

		if ( port->ValidateL() )

			{

			iPort = port;

			CleanupStack::Pop( port );

			}

		else // Data not valid.

			{

			CleanupStack::PopAndDestroy( port );

			}

		}

	}

// -----------------------------------------------------------------------------

// CWPAPPhysicalProxy::VisitL

// -----------------------------------------------------------------------------

//

void CWPAPPhysicalProxy::VisitL( CWPParameter& aParameter)

	{

	TInt id = aParameter.ID();

	const TDesC& value = aParameter.Value();

	if ( value.Length() == 0 )

		{

		// No use to store zero length value.

		return;

		}

	switch ( id )

		{

		case EWPParameterPxAddrFQDN: // iGatewayIPAddress

			{

			// Implementation comments:

			// The value of this field is a domain name but we can't 

			// at the moment resolve this to IP address 

			// (at least from this adapter).

			// Therefore this field can't be used. 

			// EWPParameterPxAddr is supported

			// and should be used.

			/// Validate the domain name

			/// Resolve to IP address

			/* // Uncomment if domain name can be validated and IP address resolved

			// Add only if we haven't already received this field

			if ( !IsReceived( EWPParameterPxAddrFQDN_id ))

				{

				iGatewayIPAddress = &aParameter;

				MarkReceived( EWPParameterPxAddrFQDN_id );

				}

			*/

			break;

			}

		case EWPParameterPxAddr: // iGatewayIPAddress

			{

			// Accept only first occurrence of either PxAddr or PxAddrFQDN

			if ( IsReceived( EWPParameterPxAddrFQDN_id ) ||

				IsReceived( EWPParameterPxAddr_id ) )

				{

				return;

				}

			else 

				{

				// The max allowed lenght for proxy address is 45 bytes. 

				// Nothing is stored if max lenght is exceeded

				if ( aParameter.Value().Length() < 46 )

					{

					iProxyAddr = &aParameter;

					MarkReceived( EWPParameterPxAddr_id );

					}

				}

			break;

			}

		case EWPParameterPxAddrType:

			{

			if ( !IsReceived( EWPParameterPxAddrType_id ) )

				{

				// Only IPv4 addresses are supported.

				if ( value == KIPV4 )

					{

					iPxAddrType = EPxAddrTypeIPv4;

					}

                else if( value == KIPV6 )

                    {

                    iPxAddrType = EPxAddrTypeIPv6;

                    }

				else

					{

					iPxAddrType = EPxAddrTypeUnsupported;

					}

				MarkReceived( EWPParameterPxAddrType_id );

				}

			break;

			}

        case EWPParameterName:

            {

            if( !iName )

                {

                iName = &aParameter;

                }

            break;

            }

		default:

			{

			// Just let through

			}

		}

	}

// -----------------------------------------------------------------------------

// CWPAPPhysicalProxy::VisitL

// -----------------------------------------------------------------------------

//

void CWPAPPhysicalProxy::VisitLinkL( CWPCharacteristic& aLink )

	{

    CWPAPNapdef* item = CWPAPNapdef::NewLC( ETrue,

                                            iDefaultName,

                                            iLogicalCharacteristic,

                                            aLink );

    User::LeaveIfError( iNapdefs.Append( item ) );

    CleanupStack::Pop( item ); // item

    }

// -----------------------------------------------------------------------------

// CWPAPPhysicalProxy::CWPAPPhysicalProxy

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CWPAPPhysicalProxy::CWPAPPhysicalProxy( 

                               const TDesC& aDefaultName, 

                               CWPCharacteristic& aLogicalCharacteristic,

                               CWPAPPort*& aPort ) 

	                         : CWPAPItemBase( aDefaultName ), 

                               iLogicalPort( aPort ),

                               iNapdefs( KInitialArraySize ),

                               iLogicalCharacteristic( aLogicalCharacteristic )

	{

	}

// -----------------------------------------------------------------------------

// CWPAPPhysicalProxy::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CWPAPPhysicalProxy::ConstructL()

	{

	}

// End of File