// Copyright (c) 1997-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:

//

#include <es_ver.h>

#include "CS_STD.H"

#include "es_flog.h"

#include <rsshared.h>

#include <comms-infras/esockdebugmessages.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <es_sock_internal.h>

#endif

#if defined (_DEBUG_SOCKET_FUNCTIONS)

#include <comms-infras/trbuf.h>

#endif

#if defined(_DEBUG) && !defined(__ESOCK_SUPPRESS_ESOCK_HANDLE_OVERWRITE_PANICS)

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ESockCSockCS_CLI, "ESockCSockCS_CLI");

#endif

#if defined (__FLOG_ACTIVE)

	/**

	@internalComponent

	*/

	struct TNo2NameMap

		{

		TUint iNumber;

		const char* iName;

		};

	/**

	they must be sorted by number!

	@internalComponent

	*/

	LOCAL_D const TNo2NameMap KAddrFamMap[] =

		{

			{ 0x0010, "smsprot" },

			{ 0x0011, "wapprot" },

			{ 0x0100, "irda"    },

			{ 0x0101, "bt"      },

			{ 0x0111, "plp"     },

			{ 0x0800, "tcpip"   },

			{ 0x0801, "ipsec6"  },

			{ 0x0803, "eaysymb" },

			{ 0x0806, "tcpip6"  },

			{ 0x08b5, "mip6"    }

		};

	/**

	@internalComponent

	*/

	#define NO2NAME(table,no) (MapNo2Name(table, sizeof(table)/sizeof(table[0]), no))

	/**

	do a binary search through the mapping table and return the

	name, if found.

	@internalComponent

	*/

	LOCAL_C const char* MapNo2Name(const TNo2NameMap* aMapping, TInt aSize, TUint aNumber)

	{

		TInt min = -1;

		TInt max = aSize;

		TInt median = 0;

		TBool found = EFalse;

		while(!found)

			{

			median = (max + min) / 2;

			if(aNumber > aMapping[median].iNumber)

				min = median;

			else if(aNumber < aMapping[median].iNumber)

				max = median;

			else

				found = ETrue;

			// to avoid forever loops

			if(median == ((max + min) / 2))

				break;

			if(min==max)

				break;

			}

		if(found)

			return aMapping[median].iName;

		else

			return "???";

		}

	/**

	@internalComponent

	*/

	LOCAL_D const char* const KSockTypeMap[5] =

		{

		"NULL",      // 0

		"stream",    // 1

		"datagram",  // 2

		"seqpacket", // 3

		"raw"        // 4

		};

	/**

	@internalComponent

	*/

	LOCAL_C const char* GetSockTypeMap(TUint aSockType)

		{

		return ( aSockType < sizeof(KSockTypeMap)/sizeof(KSockTypeMap[0]))

			?

			KSockTypeMap[aSockType]

			:

		"???";

		}

	/**

	they must be sorted by number!

	@internalComponent

	*/

	LOCAL_D const TNo2NameMap KProtocolMap[] =

		{

			{ 1,  "ICMP" },

			{ 4,  "IPv4" },

			{ 6,  "TCP"  },

			{ 17, "UDP"  },

			{ 41, "IPv6" },

			{ 50, "ESP"  },

			{ 51, "AH"   },

			{ 0x0101, "PROT_KEY"  }, // temp assignment

			{ 0x0103, "INET_HOOK" }, // temp assignment

			{ 0x0f01, "INET6_RES" }  // temp assignment (tcpip6\inc\res.h)

		};

#endif

EXPORT_C RSocketServ::RSocketServ()

/**

Default Constructor

*/

    {

    }

EXPORT_C TInt RSocketServ::Connect(TUint aMessageSlots /* =8 */)

/** Opens a session to the socket server.

The number of message slots indicates how many asychronous operations are 

allowed to be uncompleted at any one time by the combined resources opened 

on the session. The result of having too few slots is not fatal. However, 

operations may return KErrServerBusy indicating that no message slot was 

available after a small time trying.

RHandleBase::Close() should be called once the session is no longer required. 

All resources which are opened using the session will be automatically closed 

when the session terminates.

When the last session which has open resources for a protocol is closed a 

protocol module will be unloaded automatically by the socket server.

@param aMessageSlots The number of message slots required. If not specified, 8.

@return KErrNone if successful, otherwise another of the system-wide error 

codes. */

	{

	LOG( ESockLog::Printf(_L8("RSocketServ %08x:\tConnect() tid %d"), this, (TUint)RThread().Id() ));

#ifndef __ESOCK_SUPPRESS_ESOCK_HANDLE_OVERWRITE_PANICS

	__ASSERT_DEBUG(Handle() == 0, User::Panic(KSpecAssert_ESockCSockCS_CLI, 1));

#endif

	TSessionPref pref;

	TInt r = Connect(pref, aMessageSlots);

   // Because ESock is now loaded by the Comms Root Server which is generally started during

	// the boot this should commonly succeed; however for test code this is still a possibility

	// Hence here we try starting it; this is an atomic operation (and cheap if it's already started)

	if (r==KErrNotFound)

		{

		r=StartC32();

		if (r==KErrNone || r==KErrAlreadyExists)

			{

			r = Connect(pref, aMessageSlots);

			}

		}

	return(r);

	}

/**

Default Constructor, makes sure that member data doesn't contain unnitialised values.

*/

EXPORT_C TSessionPref::TSessionPref():

    iAddrFamily(KUndefinedAddressFamily),

    iProtocol(KUndefinedProtocol),

    iReserved(0),

    iReserved1(0),

    iReserved2(0),

    iReserved3(0),

    iReserved4(0)

    {}

EXPORT_C TInt RSocketServ::Connect(const TSessionPref& aPref, TUint aMessageSlots)

/** Opens a session to the socket server.

The session prefs provides a hint to the server of which protocol the client intend to use.

This might result in better performance for the connection.

The number of message slots indicates how many asychronous operations are

allowed to be uncompleted at any one time by the combined resources opened

on the session. The result of having too few slots is not fatal. However,

operations may return KErrServerBusy indicating that no message slot was

available after a small time trying.

RHandleBase::Close() should be called once the session is no longer required.

All resources which are opened using the session will be automatically closed

when the session terminates.

When the last session which has open resources for a protocol is closed a

protocol module will be unloaded automatically by the socket server.

@param aPrefs Hint for server to create most optimal connection possible.

@param aMessageSlots The number of message slots required. If not specified, 8.

@return KErrNone if successful, otherwise another of the system-wide error

codes. */

	{

	LOG( ESockLog::Printf(_L8("RSocketServ %08x:\tConnect(TSessionPref(%d,%d,%d)) tid %d"), this, aPref.iAddrFamily, aPref.iProtocol, aPref.iReserved, (TUint)RThread().Id() ));

#ifndef __ESOCK_SUPPRESS_ESOCK_HANDLE_OVERWRITE_PANICS

	__ASSERT_DEBUG(Handle() == 0, User::Panic(KSpecAssert_ESockCSockCS_CLI, 2));

#endif

	TInt err = CreateSession(SOCKET_SERVER_NAME, TVersion(), aMessageSlots);

	if(err == KErrNone)

		{

		// Now we request the optimal server and if we get one we reconnect to that one.

		TServerName prefServerName;

		TPckg<TSessionPref> prefDesc(aPref);

		err = SendReceive(ESSRequestOptimalDealer, TIpcArgs(&prefDesc, &prefServerName));

		if(err == KErrNone && prefServerName.Length() > 0)

			{

			RSocketServ oldSess = *this;

			SetHandle(0);

			err = CreateSession(prefServerName, TVersion(), aMessageSlots);

			oldSess.Close();

			}

		else if (err == KErrNotFound)

			{

			//Well then the pit boss is the optimal dealer

			err = KErrNone;

			}

		}

	return err;

	}

EXPORT_C TInt RSocketServ::NumProtocols(TUint &aCount)

/** Gets the number of protocols the socket server is currently aware of.

The count returned can be used in conjunction with GetProtocolInfo().

@param aCount The number of protocols is returned in aCount

@return KErrNone if successful, otherwise another of the system-wide error

codes. */

    {

	TPtr8 n((TUint8 *)&aCount,sizeof(aCount));

    return SendReceive(ESSNumProtocols,TIpcArgs(&n));

    }

EXPORT_C TInt RSocketServ::GetProtocolInfo(TUint anIndex,TProtocolDesc &aProtocol)

//

// Only really implemented for completeness and debugging.

//

/** Gets information about a specific protocol.

@param anIndex Index of required protocol description. 

@param aProtocol A protocol description type to hold protocol information. 

@return KErrNone if successful, otherwise another of the system-wide error codes. */

    {

	TPckg<TProtocolDesc> protDesc(aProtocol);

	return SendReceive(ESSProtocolInfo,TIpcArgs(&protDesc,anIndex));

    }

EXPORT_C TInt RSocketServ::FindProtocol(const TProtocolName& aName,TProtocolDesc &aProtocol)

/** Gets information about a specific protocol, identified by it's name.

There is no wildcard support.

@param aName Typed descriptor which identifies a protocol name. 

@param aProtocol A protocol description type to hold protocol information. 

@return KErrNone if successful, otherwise another of the system-wide error 

codes. */

    {

	TPckg<TProtocolDesc> protDesc(aProtocol);

	return SendReceive(ESSProtocolInfoByName,TIpcArgs(&protDesc,&aName));

    }

EXPORT_C void RSocketServ::StartProtocol(TUint anAddrFamily,TUint aSockType,TUint aProtocol,TRequestStatus &aStatus)

//

// Effectively makes all the lengthy parts of Open asynchronous.

//

/** Loads a specified protocol asynchronously.

The protocol is specified by family, socket type and protocol identifier. 

Note that client programs do not normally need to call this 

function, as loading of a protocol is done automatically by the Sockets Server 

when a socket of that protocol is opened. Some applications may, however, need 

to ensure that an open socket call will not take a significant amount of time 

(e.g. IrCOMM). This function can be called by such applications to preload the 

protocol. 

There is no way to cancel this operation once it has been called. 

@param anAddrFamily Integer which identifies a protocol suite.

@param aSockType Integer which identifies a type of socket.

@param aProtocol Integer which identifies a specific protocol in a family.

@param aStatus On completion will contain an error code: see the system-wide error codes. 

@capability NetworkControl Protocol starting is a critical operation in the comms process and must be restricted

*/

	{

	LOG( ESockLog::Printf(_L8("StartProtocol: client %d [addrfam=0x%04x,socktype=%d,prot=%d]"), (TUint)RThread().Id(), anAddrFamily, aSockType, aProtocol));

	SendReceive(ESSProtocolStart,TIpcArgs(anAddrFamily,aSockType,aProtocol),aStatus);

	}

EXPORT_C void RSocketServ::StopProtocol(TUint anAddrFamily,TUint aSockType,TUint aProtocol,TRequestStatus& aStatus)

/**

Unload a protocol asynchronously - note it will fail if there are any resources open

@param anAddrFamily Integer which identifies a protocol suite

@param aSockType Integer which identifies a type of socket

@param aProtocol Integer which identifies a specific protocol in a family

@param aStatus On completion, will contain a system-wide error codes

@capability NetworkControl Protocol stopping is a critical operation in the comms process and must be restricted

*/

    {

	LOG(ESockLog::Printf(_L8("StopProtocol: client %d [addrfam=0x%04x,socktype=%d,prot=%d]"), (TUint)RThread().Id(), anAddrFamily, aSockType, aProtocol));

	SendReceive(ESSProtocolStop,TIpcArgs(anAddrFamily,aSockType,aProtocol),aStatus);

    }

EXPORT_C void RSocketServ::SetExclusiveMode(TRequestStatus& aStatus)

/**

Set this session as the socket server exclusive session.

PLEASE NOTE: This API is currently unsupported, calling it will always return KErrNone but without actually doing anything.

@param aStatus On completion, will contain a system-wide error codes

@capability NetworkControl Restricting Esock to one session is very dangerous and must be highly restricted

*/

    {

	SendReceive(ESSExclusiveMode,TIpcArgs(),aStatus);

    }

EXPORT_C void RSocketServ::ClearExclusiveMode()

/**

Clear exclusive mode for this session

PLEASE NOTE: This API is currently unsupported, calling it will always return KErrNone but without actually doing anything.

*/

    {

	SendReceive(ESSClearExclusiveMode,TIpcArgs());

    }

EXPORT_C TInt RSocketServ::InstallExtension(const TDesC& aDllName, const TDesC& aArgs)

/**

Install an Esock Extension.

PLEASE NOTE: This API is currently unsupported, calling it will always return KErrNotSupported.

@param aDllName DllName for Esock Extension

@param aArgs argument for Esock Extension

@return KErrNone if successful, otherwise another of the system-wide error codes.

@capability NetworkControl Loading extensions to Esock will be behavioural changing and must be restricted to privileged apps

@deprecated Because it always return KErrNotSupported thus useless

*/

    {

		return  (aArgs.Length())

			?SendReceive(ESSInstallExtension,TIpcArgs(&aDllName,&aArgs,aArgs.Length()))

			: SendReceive(ESSInstallExtension,TIpcArgs(&aDllName,(TAny*)NULL,(TAny*)NULL));

    }

EXPORT_C TVersion RSocketServ::Version(void) const

/** Gets the version number of this client.

@return Client side version number */

	{

	return(TVersion(KES32MajorVersionNumber,KES32MinorVersionNumber,KES32BuildVersionNumber));

	}

#if defined (_DEBUG_SOCKET_FUNCTIONS)

EXPORT_C TInt RSocketServ::__DbgMarkHeap()

/**

Set a heap mark in the socket server

Marks the start of checking the current thread's heap.

@return In debug builds, KErrNone, if successful, otherwise one of the other system wide error codes. In release builds, KErrNone always.

*/

	{

	return SendReceive(ESSDbgMarkHeap,TIpcArgs());

	}

EXPORT_C TInt RSocketServ::__DbgCheckHeap(TInt aCount)

/**

Checks that the number of allocated cells on the current thread's heap is the same as the specified value

@param aCount In debug builds, the number of heap cells expected to be allocated.

@return In debug builds, KErrNone, if successful, otherwise one of the other system wide error codes

*/

	{

	return SendReceive(ESSDbgCheckHeap,TIpcArgs(aCount));//check if it's right 

	}

EXPORT_C TInt RSocketServ::__DbgMarkEnd(TInt aCount)

/**

Set a heap mark in the socket server

Marks the end of checking the current thread's heap

@param aCount In debug builds, the number of heap cells expected to be allocated.

@return In debug builds, KErrNone, if successful, otherwise one of the other system wide error codes

*/

	{

	return SendReceive(ESSDbgMarkEnd,TIpcArgs(aCount));//check if it's right 

	}

EXPORT_C TInt RSocketServ::__DbgFailNext(TInt aCount)

/**

Set a heap mark in the socket server

Simulates heap allocation failure.

@param aCount In debug builds, the number of heap cells expected to be allocated.

@return In debug builds, KErrNone, if successful, otherwise one of the other system wide error codes

*/

	{

	return SendReceive(ESSDbgFailNext,TIpcArgs(aCount));//check if it's right 

	}

EXPORT_C TBool RSocketServ::__DbgCheckFailNext() const

/**

Check whether a simulated OOM fail-next set via __DbgFailNext() is still active, generally indicates that some code

under test hasn't explored all allocation points

@return EFalse if any ESOCK server heap has left FailNext simulation mode

*/

    {

	return SendReceive(ESSDbgCheckFailNext);

	}

EXPORT_C TInt RSocketServ::__DbgFailNextMbuf(TInt aCount)

/**

Set a Mbuf mark in the socket server

Simulates Mbuf allocation failure.

@param aCount In debug builds, the number of heap cells expected to be allocated.

@return In debug builds, KErrNone, if successful, otherwise one of the other system wide error codes

*/

	{

	return SendReceive(ESSDbgFailNextMbuf,TIpcArgs(aCount));//check if it's right 

	}

EXPORT_C TInt RSocketServ::__DbgSetMbufPoolLimit(TInt aSize)

/**

Set the Mbuf pool limit

@param aSize indiactes the limit of MBuf pool.

@return In debug builds, KErrNone, if successful, otherwise one of the other system wide error codes

*/

	{

	return SendReceive(ESSDbgSetMbufPoolLimit,TIpcArgs(aSize));//check if it's right 

	}

EXPORT_C TInt RSocketServ::__DbgCheckMbuf(TInt aSize)

/**

Checks that the number of allocated cells on the current thread's MBuf is the same as the specified value

@param aSize indiactes the limit of MBuf pool.

@return In debug builds, KErrNone, if successful, otherwise one of the other system wide error codes

*/

	{

	return SendReceive(ESSDbgCheckMbuf,TIpcArgs(aSize));//check if it's right 

	}

EXPORT_C TInt RSocketServ::__DbgMbufFreeSpace()

/**

Get the amount of free space in the MBuf manager

@return free space in the MBuf manager

*/

	{

	TPckgBuf<TInt> i;

	TInt result=SendReceive(ESSDbgMbufFreeSpace,TIpcArgs(&i));

	if (KErrNone == result)

		return i();

	else

		return -1;

	}

EXPORT_C TInt RSocketServ::__DbgMbufTotalSpace()

/**

Get the amount of total space  available in the MBuf manager

@return total space  available in the MBuf manager

*/

	{

	TPckgBuf<TInt> i;

	TInt result = SendReceive(ESSDbgMbufTotalSpace,TIpcArgs(&i));

	if (KErrNone == result)

		return i();

	else

		return -1;