/*

* Copyright (c) 2007 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:  Project wide definitions.

*

*/

#ifndef NSPDEFS_H

#define NSPDEFS_H

#include "nsppluginreturndef.h"

#include <sdpconnectionfield.h>

#include <sdpmediafield.h>

#ifndef COMPONENT

#define COMPONENT

_LIT( KComponent, "NATFW SDP Provider" );

#endif // COMPONENT

#define __PANIC( aInt ) User::Panic( KComponent, aInt )

#define NSP_ERROR( status ) ( KErrNone > status )

#define NSP_ICMP( aError ) ( KErrCommsLineFail == aError )

#define NSP_TRIGGER( status ) ( KNatReady == status )

#define NSP_DELETE( status ) ( KNatReady == status )

_LIT( KNSPPrintFormat, "%S: %S" );

_LIT( KNSPPrintFormat2, "%S: %S %S" );

_LIT( KNSPPrintFormat3, "%S: %S %d" );

_LIT( KNSPPrintFormat4, "%S: %S %u" );

inline static TInetAddr ConvertTDesC8ToTInetAddrL( const TDesC8& aDesc, TUint aPort )

    {

    RBuf address;

    address.CreateL( aDesc.Length() );

    address.CleanupClosePushL();

    address.Copy( aDesc );

    TInetAddr addr;

    User::LeaveIfError( addr.Input( address ) );

    CleanupStack::PopAndDestroy( &address );

    addr.SetPort( aPort );

    return addr;

    }

inline static void ConvertTInetAddrToTDes8AndTUintL( const TInetAddr& aAddress,

    TDes8& aDes, TUint& aPort )

    {

    RBuf address;

    address.CreateL( 40 );

    address.CleanupClosePushL();

    aAddress.Output( address );

    aDes.Copy( address );

    CleanupStack::PopAndDestroy( &address );

    aPort = aAddress.Port();

    }

inline static const TDesC8& Address( CSdpMediaField& aMediafield )

    {

    return ( aMediafield.ConnectionFields().Count() ?

            aMediafield.ConnectionFields()[0]->Address() : KNullDesC8 );

    }

#define CONN_ADDR( mediafield, sessionAddr ) \

        ( Address( mediafield ).Length() ? Address( mediafield ) : sessionAddr )

#if (defined _DEBUG)

#include <e32debug.h>

#include <e32base.h>

#include <s32mem.h>

#include <sdpdocument.h>

class RBufWriteStream;

const TText* const KWarning = _S( "Text contains not allowed characters, log ignored" );

const TText8* const KCRLF = _S8( "\r\n" );

const TUint KCRLFLength = 2;

const TUint KMaxLengthOfSDPMessage = 1000;

static inline void PrintL( const TDesC& aStr )

	{

	HBufC* line = HBufC::NewLC( 256 );

	TPtr ptr( line->Des() );

	if ( KErrNotFound == aStr.Locate( TChar( '%' ) ) )

		{

		ptr.Format( KNSPPrintFormat(), &KComponent(), &aStr );

		}

	else

		{

		TPtrC warning( KWarning );

		ptr.Format( KNSPPrintFormat(), &KComponent(), &warning );

		}

	RDebug::Print( line->Des() );

	CleanupStack::PopAndDestroy( line );

	}

static inline void Print( const TDesC& aStr )

	{

	TRAP_IGNORE( PrintL( aStr ) );

	}

static inline void PrintL( const TDesC& aStr1, const TDesC& aStr2 )

	{

	HBufC* line = HBufC::NewLC( 256 );

	TPtr ptr( line->Des() );

	if ( KErrNotFound == aStr1.Locate( TChar( '%' ) ) )

		{

		ptr.Format( KNSPPrintFormat2(), &KComponent(), &aStr1, &aStr2 );

		}

	else

		{

		TPtrC warning( KWarning );

		ptr.Format( _L( "%S: %S" ), &KComponent(), &warning );

		}

	RDebug::Print( line->Des() );

	CleanupStack::PopAndDestroy( line );

	}

static inline void Print( const TDesC& aStr1, const TDesC& aStr2 )

	{

	TRAP_IGNORE( PrintL( aStr1, aStr2 ) );

	}

static inline void PrintL( const TDesC& aStr, TInt aTInt )

	{

	HBufC* line = HBufC::NewLC( 256 );

	TPtr ptr( line->Des() );

	if ( KErrNotFound == aStr.Locate( TChar( '%' ) ) )

		{

		ptr.Format( KNSPPrintFormat3(), &KComponent(), &aStr, aTInt );

		}

	else

		{

		TPtrC warning( KWarning );

		ptr.Format( _L( "%S: %S" ), &KComponent(), &warning );

		}

	RDebug::Print( line->Des() );

	CleanupStack::PopAndDestroy( line );

	}

static inline void Print( const TDesC& aStr, TInt aTInt )

	{

	TRAP_IGNORE( PrintL( aStr, aTInt ) );

	}

static inline void PrintL( const TDesC& aStr, TUint aTUint )

	{

	HBufC* line = HBufC::NewLC( 256 );

	TPtr ptr( line->Des() );

	if ( KErrNotFound == aStr.Locate( TChar( '%' ) ) )

		{

		ptr.Format( KNSPPrintFormat4(), &KComponent(), &aStr, aTUint );

		}

	else

		{

		TPtrC warning( KWarning );

		ptr.Format( _L( "%S: %S" ), &KComponent(), &warning );

		}

	RDebug::Print( line->Des() );

	CleanupStack::PopAndDestroy( line );

	}

static inline void Print( const TDesC& aStr, TUint aTUint )

	{

	TRAP_IGNORE( PrintL( aStr, aTUint ) );

	}

static inline void Log8L( const TDesC8& aDesC8 )

	{

	HBufC* buffer = HBufC::NewL( aDesC8.Length() );

	TPtr ptr( buffer->Des() );

	ptr.Copy( aDesC8 );

	Print( buffer->Des() );

	delete buffer;

	}

static inline void Log8L( const TDesC& aStr, const TDesC8& aDesC8 )

	{

	HBufC* buffer = HBufC::NewL( aDesC8.Length() );

	TPtr ptr( buffer->Des() );

	ptr.Copy( aDesC8 );

	Print( aStr, buffer->Des() );

	delete buffer;

	}

static inline HBufC8* EncodeSdpDocumentL( const CSdpDocument& aDoc )

	{

	CBufFlat* encBuf = CBufFlat::NewL( KMaxLengthOfSDPMessage );

	CleanupStack::PushL( encBuf );

	RBufWriteStream writeStream;

	CleanupClosePushL( writeStream );

	writeStream.Open( *encBuf );

	aDoc.EncodeL( writeStream );

	CleanupStack::PopAndDestroy( &writeStream );

	HBufC8* buff = encBuf->Ptr(0).AllocL();

	CleanupStack::PopAndDestroy( encBuf );

	return buff;

	}

#define NSPLOG_STR( aLit ) \

	{ _LIT( KStr, aLit ); Print( KStr() ); }

#define NSPLOG_STR2( aLit, b16 ) \

	{ _LIT( KStr, aLit ); Print( KStr(), b16 ); }

#define NSPLOG_STR3( aLit, b16, c16 ) \

	{ _LIT( KStr, aLit ); Print( KStr(), b16, c16 ); }

#define NSPLOG_INT( aLit, bInt ) \

	{ _LIT( KStr, aLit ); Print( KStr(), bInt ); }

#define NSPLOG_UINT( aLit, bUInt ) \

	{ _LIT( KStr, aLit ); Print( KStr(), bUInt ); }

#define NSPLOG8_STR( a8 ) \

	{ Log8L( a8 ); }

#define NSPLOG8_STR2( aLit, b8 ) \

	{ _LIT( KStr, aLit ); Log8L( KStr(), b8 ); }

#define NSPLOG8_DOC_L( aDoc ) \

	{\

	HBufC8* buffer = EncodeSdpDocumentL( aDoc );\

	CleanupStack::PushL( buffer );\

	TPtrC8 ptr( buffer->Des() );\

	while( ptr.Length() )\

		{\

		const TInt length = ptr.Length();\

		const TInt index = ptr.Find( TPtrC8( KCRLF ) );\

		const TInt left = ( KErrNotFound != index ? index : length );\

		const TInt right = ( length - KCRLFLength - left );\

		HBufC8* line = ptr.Left( left ).AllocLC();\

		Log8L( line->Des() );\

		CleanupStack::PopAndDestroy( line );\

        ptr.Set( ptr.Right( 0 < right ? right : 0 ) );\

	  }\

	CleanupStack::PopAndDestroy( buffer );\

	}

#define NSPDEBUG_PANIC( aInt ) \

	NSPLOG_INT( "NATFW SDP Provider!! code:", aInt ) __PANIC( aInt )

#if (defined NSP_PRINT_INPUT)

#define NSP_INPUT_OFFER_L( aOffer ) \

    {\

	NSPLOG_STR( "============ INPUT OFFER =============" )\

    NSPLOG8_DOC_L( aOffer )\

    NSPLOG_STR( "======================================" )\

    }

#define NSP_INPUT_OFFER( aOffer ) \

    TRAP_IGNORE( NSP_INPUT_OFFER_L( aOffer ) );

#define NSP_INPUT_ANSWER_L( aAnswer ) \

    {\

    NSPLOG_STR( "============ INPUT ANSWER ============" )\

    NSPLOG8_DOC_L( aAnswer )\

    NSPLOG_STR( "======================================" )\

    }

#define NSP_INPUT_ANSWER( aAnswer ) \

    TRAP_IGNORE( NSP_INPUT_ANSWER_L( aAnswer ) );

#else // NSP_PRINT_INPUT

#define NSP_INPUT_OFFER_L( aOffer )

#define NSP_INPUT_OFFER( aOffer )

#define NSP_INPUT_ANSWER_L( aAnswer )

#define NSP_INPUT_ANSWER( aAnswer )

#endif // NSP_PRINT_INPUT

#if (defined NSP_PRINT_OUTPUT)

#define NSP_OUTPUT_INITIALIZED \

	{\

	NSPLOG_STR( "============ INITIALIZED =============" )\

	NSPLOG_STR( "======================================" )\

	}

#define NSP_OUTPUT_OFFER_L( aStatus, aOffer ) \

    if ( KNatReady == aStatus )\

		{\

		NSPLOG_STR( "============ OUTPUT OFFER ============" )\

	    NSPLOG8_DOC_L( aOffer )\

	    NSPLOG_STR( "======================================" )\

		}

#define NSP_OUTPUT_OFFER( aStatus, aOffer ) \

    TRAP_IGNORE( NSP_OUTPUT_OFFER_L( aStatus, aOffer ) );

#define NSP_OUTPUT_ANSWER_L( aStatus, aAnswer ) \

    if ( KNatReady == aStatus )\

		{\

	    NSPLOG_STR( "============ OUTPUT ANSWER ===========" )\

	    NSPLOG8_DOC_L( aAnswer )\

	    NSPLOG_STR( "======================================" )\

		}

#define NSP_OUTPUT_ANSWER( aStatus, aAnswer )  \

    TRAP_IGNORE( NSP_OUTPUT_ANSWER_L( aStatus, aAnswer ) );

#define NSP_OUTPUT_UPDATESDP_L( aStatus, aOffer ) \

	if ( KNatReady == aStatus )\

		{\

		NSPLOG_STR( "============ UPDATED SDP =============" )\

	    NSPLOG8_DOC_L( aOffer )\

		NSPLOG_STR( "======================================" )\

		}

#define NSP_OUTPUT_UPDATESDP( aStatus, aOffer ) \

	TRAP_IGNORE( NSP_OUTPUT_UPDATESDP_L( aStatus, aOffer ) );

#define NSP_OUTPUT_ERROR( aError ) \

	{\

	NSPLOG_STR( "============ OUTPUT ERROR ============" )\

	NSPLOG_INT( ":", aError )\

	NSPLOG_STR( "======================================" )\

	}

#else // NSP_PRINT_OUTPUT

#define NSP_OUTPUT_INITIALIZED

#define NSP_OUTPUT_OFFER_L( aStatus, aOffer )

#define NSP_OUTPUT_OFFER( aStatus, aOffer )

#define NSP_OUTPUT_ANSWER_L( aStatus, aAnswer )

#define NSP_OUTPUT_ANSWER( aStatus, aAnswer )

#define NSP_OUTPUT_UPDATESDP_L( aStatus, aOffer )

#define NSP_OUTPUT_UPDATESDP( aStatus, aOffer )

#define NSP_OUTPUT_ERROR( aError )

#endif // NSP_PRINT_OUTPUT

#else // _DEBUG

#define NSPLOG_STR( aLit )

#define NSPLOG_STR2( aLit, b16 )

#define NSPLOG_STR3( aLit, b16, c16 )

#define NSPLOG_INT( aLit, bInt )

#define NSPLOG_UINT( aLit, bUInt )

#define NSPLOG8_STR( a8 )

#define NSPLOG8_STR2( aLit, b8 )

#define NSPLOG8_DOC_L( aDoc )

#define NSPDEBUG_PANIC( aInt )

#define NSP_INPUT_OFFER_L( aOffer )

#define NSP_INPUT_OFFER( aOffer )

#define NSP_INPUT_ANSWER_L( aAnswer )

#define NSP_INPUT_ANSWER( aAnswer )

#define NSP_OUTPUT_INITIALIZED

#define NSP_OUTPUT_OFFER_L( aStatus, aOffer )

#define NSP_OUTPUT_OFFER( aStatus, aOffer )

#define NSP_OUTPUT_ANSWER_L( aStatus, aAnswer )

#define NSP_OUTPUT_ANSWER( aStatus, aAnswer )

#define NSP_OUTPUT_UPDATESDP_L( aStatus, aOffer )

#define NSP_OUTPUT_UPDATESDP( aStatus, aOffer )

#define NSP_OUTPUT_ERROR( aError )

#endif // _DEBUG

#endif // NSPDEFS_H

// end of file