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

//

/**

 @file SS_SAPSHIM.CPP

*/

#define SYMBIAN_NETWORKING_UPS

#include "ss_sapshim.h"

#include <ss_std.h>

#include <ss_glob.h>

#include <comms-infras/ss_roles.h>

#include <comms-infras/ss_log.h>

#include <comms-infras/ss_subconnprov.h>

#include <comms-infras/ss_connprov.h>

#include <ss_protprov.h>

#include <ss_sock.h>

#include <comms-infras/ss_protflow.h>

#include <in_sock.h> // KAfInet

#include <elements/nm_messages_child.h>

#include <elements/nm_messages_peer.h>

#include <comms-infras/nifif.h>

#include <comms-infras/nifif_internal.h>

#include <addressupdate.h>

#include <comms-infras/ss_nodemessages_dataclient.h>

#include <comms-infras/ss_nodemessages_flow.h>

#include <comms-infras/ss_nodemessages_ipmessages.h>

#include <comms-infras/ss_nodemessages_internal_esock.h>

#include "ss_protopt.h"

#ifdef SYMBIAN_NETWORKING_UPS

#include <comms-infras/ss_upsaccesspointconfigext.h>

#include <comms-infras/upsmessages.h>

#ifdef _DEBUG

// 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_ESockSSocksspshm, "ESockSSocksspshm");

#endif

_LIT_SECURITY_POLICY_C1(KPolicyNetworkServices, ECapabilityNetworkServices);

#endif

using namespace ESock;

using namespace Messages;

using namespace MeshMachine;

using namespace Factories;

//CHostResolver specific functions this is to remove once we have app layer protocols

//***************************************************************************************

//also loo for iHostResolverNotify

MLowerControl* CTransportFlowShim::GetControlL(const TDesC8& /*aProtocol*/)

    {

    return this;

    }

TInt CTransportFlowShim::Control(TUint aLevel, TUint aName, TDes8& aOption)

    {

    return iLowerControl ? iLowerControl->Control(aLevel, aName, aOption) : KErrNotReady;

    }

MLowerDataSender* CTransportFlowShim::BindL(const TDesC8& /*aProtocol*/, MUpperDataReceiver* aReceiver, MUpperControl* aControl)

    {

    if (aReceiver || iProvider || IsBoundToSession())

        {

        User::Leave(KErrInUse);

        }

    iSubConnectionProvider.PostMessage(Id(), TCFControlProvider::TActive().CRef());

    iHostResolverNotify = aControl;

    return this;

    }

void CTransportFlowShim::Unbind( MUpperDataReceiver* /*aReceiver*/, MUpperControl* aControl)

    {

    (void)aControl;

    __ASSERT_DEBUG(aControl == iHostResolverNotify, User::Panic(KSpecAssert_ESockSSocksspshm, 1));

    __ASSERT_DEBUG(iDCIdle <= EClientsPresent, User::Panic(KSpecAssert_ESockSSocksspshm, 2));

    iDCIdle = EIdle;

    iHostResolverNotify = NULL;

    if(iSubConnectionProvider.IsOpen())	// legacy flows have no control side

    	{

    	ProcessDCIdleState();

    	}

    }

MLowerDataSender::TSendResult CTransportFlowShim::Send(RMBufChain& /*aData*/)

    {

    __ASSERT_DEBUG(iHostResolverNotify, User::Panic(KSpecAssert_ESockSSocksspshm, 3));

    TBuf8<sizeof(TConnectionInfo)> buf;

    if (Control(KSOLProvider, static_cast<TUint>(KSoConnectionInfo), buf) == KErrNone)

        {

        iHostResolverNotify->StartSending();

        }

    else if (!iLowerControl)

        {

#ifdef SYMBIAN_NETWORKING_UPS

		TInt result = SetupForNoBearerOnSend();

		if (result != KErrNone)

			{

			return TSendResult(result);

			}

#endif

		__ASSERT_DEBUG(iSubConnectionProvider.IsOpen(), User::Panic(KSpecAssert_ESockSSocksspshm, 4));	// legacy flows have no control side, so must never get here

        PostNoBearer();

        }

    return MLowerDataSender::ESendAccepted;

    }

//***************************************************************************************

//End of CHostResolver specific functions also look for iHostResolverNotify to find the rest

#ifndef SYMBIAN_NETWORKING_UPS

//

// Not used with UPS support - CUpsTransportFlowShim::NewL() used instead.

//

CTransportFlowShim* CTransportFlowShim::NewL(CSubConnectionFlowFactoryBase& aFactory, const TNodeId& aSubConn, CProtocolIntfBase* aProtocolIntf)

	{

	return new (ELeave) CTransportFlowShim(aFactory, aSubConn, aProtocolIntf);

	}

#endif

CTransportFlowShim::CTransportFlowShim(CSubConnectionFlowFactoryBase& aFactory, const TNodeId& aSubConn, CProtocolIntfBase* aProtocolIntf)

	{

    LOG_NODE_CREATE(KESockFlowTag, CTransportFlowShim)

	}

void CTransportFlowShim::SetSSP(CServProviderBase& aSSP)

	{

	__ASSERT_DEBUG(iProvider == NULL, User::Panic(KSpecAssert_ESockSSocksspshm, 5));

	iProvider = &aSSP;

	iProvider->SetNotify(this);

	}

CTransportFlowShim::~CTransportFlowShim()

	{

	// Remove ourselves from any listening control session's accept queue.

	if(iListenerControlNotify)

		{

		iListenerControlNotify->DisconnectFromListener(*this);

		}

	if(!iDetaching)

		{

		delete iProvider;

		iProvider = NULL;

		}

	Messages::TEBase::TError err(TEBase::TNull::Id(), KErrBindersInvalid);

    SubConnectionError(err, EErrorAllOperations);

    LOG_NODE_DESTROY(KESockFlowTag, CTransportFlowShim)

	}

void CTransportFlowShim::SetSockType(TUint aSockType)

	{

	if (iProvider)

		{

		iProvider->SetSockType(aSockType);

		}

	}

MSessionControl* CTransportFlowShim::GetControlL(TInt aSessionType,MSessionControlNotify& aSessionControlNotify)

    {

    CNetworkFlow::GetControlL(aSessionType,aSessionControlNotify);

    SetSockType(aSessionType);

	return this;

    }

MSessionData* CTransportFlowShim::BindL(MSessionDataNotify& aNotify)

    {

	LOG( ESockLog::Printf(_L8("CTransportFlowShim %08x:\tBindL(aNotify 0x%08x)"), this, &aNotify) );

	// The flow shim now manages custody and loading of the protocol involved.

	// However in the case of host resolvers, until ported for the same behaviour, protocol loading is still managed by the socket.

	if(iFlowParams.iFlowLoadsProtocol)

		{

		CProtocolRef * protocolReference = ProtocolManager::FindProtocolL(

			iFlowParams.iAddrFamily,

			iFlowParams.iSocketType,

			iFlowParams.iProtocol);

        if (protocolReference->GetFlag() & CProtocolRef::EThreePlaneCommsBased)

            {

            // Three plane comms protos should not be seen here. If an RSocket is opened with a supported

            // protocol and it happens to be 3PC this point will be reached. In the case of RTP some

            // special processing is performed (in the SCPR) in order to sort out the mess and ensure that

            // a UDP/TCP flow is requested instead.

            User::Leave(KErrProtocolNotReady);

            }

        // Check if the protocol is supported over sockets

        if (!(protocolReference->Info().iServiceTypeInfo & ESocketSupport))

            {

            User::Leave(KErrNotSupported);

            }

        // Have the protocol loaded if not already the case and confirm it has socket support

        protocolReference->LoadAndBindL();

        __ASSERT_DEBUG(iProtocolReference == NULL, User::Panic(KSpecAssert_ESockSSocksspshm, 6));

        iProtocolReference = protocolReference;

        // Have the protocol added to the list of protocols for the session it is associated with

        CSockSessionProxy* sessionProxy = reinterpret_cast<CSockSessionProxy*>(iFlowParams.iSessionProxy);

        if(sessionProxy != NULL)

            {

            sessionProxy->AddProtocolL(iProtocolReference->Protocol());

            }

        // Fetch a new SAP from the protocol for this flow

        if (iProvider == NULL)

            {

            iProvider = iProtocolReference->Protocol()->NewSAPL(iFlowParams.iSocketType);

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

            // Set the options iterating the RArray variable

            SetProtocolOptions();

#endif //SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

            if (iProvider)

                {

                iProvider->SetNotify(this);

                }

            }

		}

    // Now perform the binding proper

    if (!iProvider)

        {

        User::Leave(KErrNotSupported);

        }

    __ASSERT_DEBUG(!iHostResolverNotify, User::Panic(KSpecAssert_ESockSSocksspshm, 8));

    CNetworkFlow::BindL(aNotify);

    iProvider->SetNotify(this);

	return this;

    }

void CTransportFlowShim::Unbind()

    {

	LOG( ESockLog::Printf(_L8("CTransportFlowShim %08x:\tUnbind()"), this) );

	// Infant mortality case in which binding never completed,

		{

		delete this;

		return;

		}

	// Legacy support for host resolvers

	if(iHostResolverNotify)

		{

		__ASSERT_DEBUG(!iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 9));	// can't have both HR & SAP

		LOG( ESockLog::Printf(_L8("CTransportFlowShim %08x:\tUnbind(): iBearerExpected %d"), this, iBearerExpected) );

		if (!iBearerExpected)

			{

			delete this;

			}

		else

			{

			iDeleteUponBearerReception = ETrue;

			iHostResolverNotify = NULL;

			}

		return;

		}

	if (iProvider)

		{

		iProvider->SetNotify(NULL);

		if (!iDetaching)

			{

			delete iProvider;

			iProvider = NULL;

			}

		}

#ifdef SYMBIAN_NETWORKING_UPS

	// Hook for derived classes to do cleanup before unbind occurs

	PreUnbind();

#endif

	CNetworkFlow::Unbind();

    }

ESock::CSubConnectionFlowBase& CTransportFlowShim::CloneFlowL()

    {

    __ASSERT_DEBUG(iProtocolIntf, User::Panic(KSpecAssert_ESockSSocksspshm, 10));

    TDefaultFlowFactoryQuery query (iProtocolIntf->ControlProviderId(), iSubConnectionProvider.RecipientId());

	ESock::CSubConnectionFlowBase& flow = static_cast<ESock::CSubConnectionFlowBase&>(*(Factory().CreateObjectL(query)));

	// Legacy flows lack a control provider

	if(iSubConnectionProvider.IsOpen())

		{

		TCFPeer::TJoinRequest msg(flow.Id(), TClientType(TCFClientType::EData, TCFClientType::EActive));

		iSubConnectionProvider.PostMessage(Id(), msg);

		}

	return flow;

    }

void CTransportFlowShim::Start()

	/**

	Start a service provider.

	*/

	{

	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 11));

	iProvider->Start();

	}

void CTransportFlowShim::LocalName(TSockAddr& anAddr) const

/** Gets the local name (address) of the socket service provider entity. The format

of the data in the TSockAddr object is defined by individual protocols.

The local address is the address of the local machine plus a local port number.

Generally only the port number is important, unless you have two IP interfaces,

for example.

@param anAddr The address to be filled in */

	{

	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 12));

	iProvider->LocalName(anAddr);

	}

void CTransportFlowShim::SetLocalName(TSockAddr& anAddr)

/** Sets the local name (address) of the socket service provider entity. The format

of the data in the TSockAddr object is defined by individual protocols.

@param anAddr The address */

	{

	CNetworkFlow::SetLocalName(anAddr);

	PostDataClientRouted();

	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 65));

	TInt err = iProvider->SetLocalName(anAddr);

	if (err != KErrNone)

		{

		// Post TError to self, which will result in SubConnectionError to

		// be called in the TError handling. Have to fake that the message is

		// coming from iSubConnectionProvider otherwise ReceivedL will leave.

		RClientInterface::OpenPostMessageClose(iSubConnectionProvider.RecipientId(), Id(), TEBase::TError(err).CRef());

		return;

		}

	SetLocalNameProcess();

	}

void CTransportFlowShim::SetLocalNameProcess()

	{

	TBool bearerSent = EFalse;

	if(iFlowParams.iFlowRequestType != TFlowParams::EImplicit)

		{

		// For explicit sockets, TNoBearer will be sent out if it has not already

		// been done so. This was introduced for PREQ2279, as it is necessary

		// to lock this SAP to an interface for incoming sockets. Once locked,

		// this ensures that any incoming packets are only accepted over the locked down

		// interface and no other interfaces. To lock the interface down the

		// NoBearer sequence is executed. This change will also now apply to

		// outgoing explicit sockets. The change for outgoing explicit sockets is

		// that the NoBearer sequence is started here instead of when receiving

		// a NoBearer upcall from the protocol.

		// Attempt to send out TNoBearer.

		if (DoNoBearer())

		    {

		    // TNoBearer was sent out.

			bearerSent = ETrue;

		    }

		}

	if (!bearerSent)

		{

		// No Bearer was already sent out earlier, or this is an implicit socket.

		iSessionControlNotify->SetLocalNameComplete();

		}

	}

TBool CTransportFlowShim::DoNoBearer()

/**

Do the actual no Bearer call.

@return ETrue if the NoBearer post was actually done, EFalse otherwise

*/

	{

	TInt ret = EFalse;

	if(!iIsStopped)

		{ // Prevent sending NoBearer if DataClientStop was received

		if (LockToConnectionInfo() != KErrNone)

		    {

	        __ASSERT_DEBUG(iSubConnectionProvider.IsOpen(), User::Panic(KSpecAssert_ESockSSocksspshm, 66));

			PostNoBearer();

			ret = ETrue;

		    }

		iUseBearerErrors = EFalse;

		ClearDataClientRoutedGuard();

		}

	return ret;

	}

void CTransportFlowShim::RemName(TSockAddr& anAddr) const

/** Gets the remote name (address) of the socket service provider entity. The format

of the data in the TSockAddr object is defined by individual protocols.

A remote address is either the address you're sending data to (non connection-oriented

sockets)* or the remote end of the connection. It is the address of the remote

machine (your peer in the network) plus a port number.

@note RemName is only meaningful if the socket server client has called Connect()

to set up a default address for SendTo(). This function will only be called

on the protocol if this is the case.

@param anAddr The address to be filled in */

	{

	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 14));

	iProvider->RemName(anAddr);

	}

TInt CTransportFlowShim::SetRemName(TSockAddr& anAddr)

/** Sets the remote name (address) of the socket service provider entity. The format

of the data in the TSockAddr object is defined by individual protocols.

@param anAddr The address

@return Returns KErrNone if the remote name is correctly set or, if this is

not the case, an informative error number. */

	{

	CNetworkFlow::SetRemName(anAddr);

	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 15));

	return iProvider->SetRemName(anAddr);

	}

TInt CTransportFlowShim::GetOption(TUint aLevel, TUint aName, TDes8& anOption) const

/** Gets some protocol specific option when called by the socket server on behalf of a

client. A protocol may pass the request down a protocol	stack (to protocols it is bound

to) using the GetOption() function of CProtocolBase.

@param aLevel Option level.

@param aName Option name.

@param anOption Option data.

@return System wide error code.

*/

	{

	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 16));

	return iProvider->GetOption(aLevel, aName, anOption);

	}

void CTransportFlowShim::Ioctl(TUint aLevel, TUint aName, TDes8* anOption)

/** Performs some protocol specific IO control.

@note If this function is called erroneously, the protocol should call Error() on the

socket. If an Ioctl call is already outstanding, the client will be panicked with the

value ETwoIoctls.

@param aLevel Option level.

@param aName Option name.

@param anOption Option data.

*/

	{

	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 17));

	iProvider->Ioctl(aLevel, aName, anOption);

	}

void CTransportFlowShim::CancelIoctl(TUint aLevel, TUint aName)

/** Cancels an outstanding Ioctl call. You are guaranteed only to have one outstanding

at once.

@param aLevel IOCTL level.

@param aName IOCTL name.

*/

	{

	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 18));

	iProvider->CancelIoctl(aLevel, aName);

	}

TInt CTransportFlowShim::SetOption(TUint aLevel, TUint aName, const TDesC8 &anOption)

/** Sets some protocol specific option when called by the socket server on behalf of a

client. A protocol may pass the request down a protocol	stack (to protocols it is bound

to) using the SetOption() function	of CProtocolBase.

@param aLevel Option level.

@param aName Option name.

@param anOption Option data.

@return System wide error code.

*/

	{

	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 19));

	return iProvider->SetOption(aLevel, aName, anOption);

	}

void CTransportFlowShim::ActiveOpen()

/** Initiates a connection operation - this means that it tells the protocol to

attempt to connect to a peer. It is called by the socket server in response

to a connect request from a client.

This version of the function has user data in the connection frame.

Only ever called on connection-oriented sockets. Such a socket