/*
* Copyright (c) 2009 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:  UDP protocol implementation for IP proxy
*
*/



// INCLUDE FILES
#include "CProtocolUDP.h"
#include "CExprUDPMsg.h"
#include "MSocketWriter.h"
#include "MProtocolObserverUDP.h"
#include "CommRouterDefinitions.h"

#define DEBUG_FILENAME "IPProxyEngine.log"
#include "DebugPrint.h"


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

// -----------------------------------------------------------------------------
// CProtocolUDP::CProtocolUDP
// -----------------------------------------------------------------------------
//
CProtocolUDP::CProtocolUDP( MProtocolObserverUDP* aObserver )
    : iObserver( aObserver )
    {
    __ASSERT_DEBUG( iObserver, User::Invariant() );
    }

// -----------------------------------------------------------------------------
// CProtocolUDP::ConstructL
// -----------------------------------------------------------------------------
//
void CProtocolUDP::ConstructL()
    {
    // Add all the expressions for UDP
    iExpressionArray = new (ELeave) CArrayPtrFlat<MBPExpression> ( 3 );

    CExprUDPMsg* UDPMsg = CExprUDPMsg::NewL( this );
    iExpressionArray->AppendL( UDPMsg );
    }

// -----------------------------------------------------------------------------
// CProtocolUDP::NewL
// -----------------------------------------------------------------------------
//
CProtocolUDP* CProtocolUDP::NewL( MProtocolObserverUDP* aObserver )
    {
    CProtocolUDP* self = CProtocolUDP::NewLC( aObserver );
    CleanupStack::Pop();

    return self;
    }

// -----------------------------------------------------------------------------
// CProtocolUDP::NewLC
// -----------------------------------------------------------------------------
//
CProtocolUDP* CProtocolUDP::NewLC( MProtocolObserverUDP* aObserver )
    {
    CProtocolUDP* self = new( ELeave ) CProtocolUDP( aObserver );
    CleanupStack::PushL( self );

    self->ConstructL();
    return self;
    }


// -----------------------------------------------------------------------------
// CProtocolUDP::~CProtocolUDP
// -----------------------------------------------------------------------------
//
CProtocolUDP::~CProtocolUDP()
    {
    if ( iExpressionArray )
        {
        iExpressionArray->ResetAndDestroy();
        delete iExpressionArray;
        }
    }

// -----------------------------------------------------------------------------
// CProtocolUDP::FrameStarted
// -----------------------------------------------------------------------------
//
void CProtocolUDP::FrameStarted()
    {
    iObserver->FrameStarted();
    }

// -----------------------------------------------------------------------------
// CProtocolUDP::FrameParsedL
// -----------------------------------------------------------------------------
//
void CProtocolUDP::FrameParsedL( TUint aPort, const TDesC8& aData )
    {
    iObserver->UDPFrameParsedL( aPort, aData );
    }

// -----------------------------------------------------------------------------
// CProtocolUDP::ProtocolErrorL
// -----------------------------------------------------------------------------
//
void CProtocolUDP::ProtocolErrorL(
    TInt aErrorCode, const TDesC8& aReceivedData )
    {
    iObserver->ProtocolErrorL( aErrorCode, aReceivedData );
    }


// -----------------------------------------------------------------------------
// CProtocolUDP::WriteFrameL
// -----------------------------------------------------------------------------
//
void CProtocolUDP::WriteFrameL( MSocketWriter& aSocketWriter,
            TUint aPeerPort, TUint aOriginalPort, const TDesC8& aData ) const
    {
    DEBUG_PRINT( DEBUG_STRING(
        "CProtocolUDP::WriteFrameL(), peer port=%d, original port=%d" ),
        aPeerPort, aOriginalPort );

    TInt bufSize = 0;
    bufSize += KUDPPrefix().Length();
    bufSize += KHexDecimalLength;
    bufSize += KPortSuffix().Length();
    bufSize += KHexDecimalLength;
    bufSize += KLengthSuffix().Length();
    bufSize += aData.Length();
    bufSize += KDataSuffix().Length();
    bufSize += KMessageSuffix().Length();
    
    TBuf8<KHexDecimalLength> hexbuf;
    HBufC8* buf = HBufC8::NewLC( bufSize );
    TPtr8 ptr( buf->Des() );
    
    // Append UDP prefix
    ptr.Append( KUDPPrefix );

    // Append peer port
    hexbuf.Format( KHexFormat, aPeerPort );
    ptr.Append( hexbuf );
    ptr.Append( KPortSuffix );

    // Append data length
    hexbuf.Format( KHexFormat, aData.Length() );
    ptr.Append( hexbuf );
    ptr.Append( KLengthSuffix );

    // Append data
    ptr.Append( aData );
    ptr.Append( KDataSuffix );
    ptr.Append( KMessageSuffix );
    
    // Write to socket
    aSocketWriter.WriteL( *buf );

    CleanupStack::PopAndDestroy( buf );
    }

// -----------------------------------------------------------------------------
// CProtocolUDP::HandleReceivedDataL
// -----------------------------------------------------------------------------
//
TBool CProtocolUDP::HandleReceivedDataL( TDes8& aData, TInt& aStartPos,
                                         TInt& aLength )
    {
    TBool msgHandled = EFalse;
    TInt protCount = iExpressionArray->Count();

    for ( TInt i = 0; i < protCount; i++ )
        {
        msgHandled = iExpressionArray->At( i )->HandleRecievedMsgL( aData,
                                                                    aStartPos,
                                                                    aLength);
        if ( msgHandled )
            {
            break;
            }
        }

    return msgHandled;
    }
//  End of File