/*

* 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:    

*

*/

#include <es_sock.h>

#include <in_sock.h>

#include <e32base.h>

// Local helper functions:

LOCAL_C TInt SimulateAllocFailure(TInt aError=KErrNone);

LOCAL_C void CompleteAsyncRequest(TRequestStatus& aStatus, TInt aError=KErrNone);

LOCAL_C void SimulateAllocFailureL()

    {

    HBufC* tmp = HBufC::NewL(10);

    delete tmp;

    }    

LOCAL_C TInt SimulateAllocFailure(TInt aError)

    {

    TInt err = aError;

    if (err == KErrNone)

        {

        TRAP(err, SimulateAllocFailureL());

        }

    return err;

    }

LOCAL_C void CompleteAsyncRequest(TRequestStatus& aStatus, TInt aError)

    {

    TInt err = SimulateAllocFailure(aError);

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err); 

    }

// TSockAddr

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

// TSockAddr::TSockAddr

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

//

TSockAddr::TSockAddr()

 : TBuf8<KMaxSockAddrSize>()

	{

	SetLength(KMaxSockAddrSize);

	SetFamily(KAFUnspec);   

    }

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

// TSockAddr::TSockAddr

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

//

TSockAddr::TSockAddr(TUint aFamily)

	: TBuf8<KMaxSockAddrSize>()

	{

	SetLength(KMaxSockAddrSize);

	SetFamily(aFamily);

    }

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

// TSockAddr::Family

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

//

TUint TSockAddr::Family() const

    {

    return BasePtr()->iFamily;

    }

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

// TSockAddr::SetFamily

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

//

void TSockAddr::SetFamily(TUint aFamily)

    {

	BasePtr()->iFamily = aFamily;

    }

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

// TSockAddr::Port

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

//

TUint TSockAddr::Port() const

    {

    return BasePtr()->iPort;

    }

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

// TSockAddr::SetPort

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

//

void TSockAddr::SetPort(TUint aPort)

    {

    BasePtr()->iPort = aPort;

    }

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

// TSockAddr::CmpPort

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

//

TBool TSockAddr::CmpPort(const TSockAddr& anAddr) const

    {

	return (BasePtr()->iFamily==anAddr.BasePtr()->iFamily) 

		&& (BasePtr()->iPort==anAddr.BasePtr()->iPort);

    }

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

// TSockAddr::SetUserLen

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

//

void TSockAddr::SetUserLen(TInt aLen)

	{

	SetLength(aLen+Align4(sizeof(SSockAddr)));

	}

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

// TSockAddr::GetUserLen

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

//

TInt TSockAddr::GetUserLen()

	{

	return Length()-Align4(sizeof(SSockAddr));

	}

// RSocketServ:

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

// RSocketServ::RSocketServ

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

//

RSocketServ::RSocketServ()

    {

    }

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

// RSocketServ::Connect

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

//    

TInt RSocketServ::Connect(TUint /*aMessageSlots*/)

    {

    return SimulateAllocFailure();

    }

// RConnection:

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

// RConnection::RConnection

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

//

RConnection::RConnection() 

 : iNewISPId(0)

	{

	}

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

// RConnection::~RConnection

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

//

RConnection::~RConnection()

	{

	}	

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

// RConnection::Open

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

//

TInt RConnection::Open(

    RSocketServ& /*aSocketServer*/, 

    TUint /*aConnectionType*/) 

	{

	return SimulateAllocFailure();

	}	

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

// RConnection::Close

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

//

void RConnection::Close()

    {

    }

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

// RConnection::Start

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

//

TInt RConnection::Start( TConnPref& /*aPref*/ )

    {

    return SimulateAllocFailure();    

    }

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

// RConnection::GetIntSetting

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

//

TInt RConnection::GetIntSetting( 

    const TDesC& /*aSettingName*/,

    TUint32& aValue )

	{

	TInt err = SimulateAllocFailure();

	if ( err == KErrNone )

	    {

	    aValue = 1;

	    }

	return err;

	}

// RSocket:

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

// RSocket::RSocket

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

//

RSocket::RSocket() 

 : iLocalAddrResolved(EFalse)

    {

    }

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

// RSocket::Open

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

//	

TInt RSocket::Open(

    RSocketServ& /*aServer*/,

    TUint /*addrFamily*/,

    TUint /*sockType*/,

    TUint /*protocol*/)

    {

    return SimulateAllocFailure();

    }

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

// RSocket::Close

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

//

void RSocket::Close()

    {

    }

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

// RSocket::SetOpt

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

//

TInt RSocket::SetOpt(

    TUint /*anOptionName*/,

    TUint /*anOptionLevel*/,

    const TDesC8& /*anOption*/)

    {

    return SimulateAllocFailure();

    }

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

// RSocket::GetOpt

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

//

TInt RSocket::GetOpt(

    TUint anOptionName,

    TUint anOptionLevel,

    TDes8& anOption)

    {

    TInt err = SimulateAllocFailure();

    if (err == KErrNone)

        {

        if (iLocalAddrResolved)

            {

            // See CMceLocalAddrResolver

            iLocalAddrResolved = EFalse;

            return KErrNotFound;

            }

	    if (anOptionName == KSoInetNextInterface && 

	        anOptionLevel == KSolInetIfCtrl)

	        {

	        TPckgBuf<TSoInetInterfaceInfo>& infoBuf =

	            reinterpret_cast<TPckgBuf<TSoInetInterfaceInfo>&>(anOption);    

	        infoBuf().iAddress.SetAddress(INET_ADDR(1,2,3,4));

	        }

        if (anOptionName == KSoInetIfQueryByName && 

            anOptionLevel == KSolInetIfQuery)

			{

			// Local address being resolved

			TPckgBuf<TSoInetIfQuery>& queryBuf = 

			    reinterpret_cast<TPckgBuf<TSoInetIfQuery>&>(anOption);

			queryBuf().iZone[1] = 1; // IAP id

			iLocalAddrResolved = ETrue;

			}

        }

    return err;

    }