// Copyright (c) 2003-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 <comms-infras/nifprvar.h>

#include <es_sock.h>

#include <comms-infras/sockmes.h>

#include <connpref.h>

#include "es_flog.h"

#include <comms-infras/es_commsdataobject.h>

#include <es_sock_partner.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_ESockCSockRCnctn, "ESockCSockRCnctn");

#endif

// Forward declearation

namespace ESock

{

class XConnectionQueryBase;

}

EXPORT_C RConnection::RConnection()

	: iNewISPId(0)	//lint -esym(1401, RConnection::iReserved)	// no BC issue as ctor not inlined

/** Empty constructor. */

	{

	}

EXPORT_C RConnection::~RConnection()

/** Empty destructor. */

	{

	}

EXPORT_C TInt RConnection::Open(RSocketServ& aSocketServer, TUint aConnectionType)

/** Opens a new RConnection instance.

@param aSocketServer Socket Server session.

@param aConnectionType Reserved.

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

codes. */

	{

	RSessionBase& s = aSocketServer;

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

	return CreateSubSession(s, ECNCreate, TIpcArgs(aConnectionType));

	}

EXPORT_C TInt RConnection::Open(RSocketServ& aSocketServer, TName& aName)

/** Opens a new RConnection instance cloned from an existing RConnection instance.

@param aSocketServer Socket Server session.

@param aName Name of an existing RConnection (obtainable via Name() method).

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

codes.

@capability Dependent on the type of connection so deferred to PRT */

	{

	RSessionBase& s = aSocketServer;

	return CreateSubSession(s, ECNCreateWithName, TIpcArgs(&aName));

	}

EXPORT_C void RConnection::Close()

/** Closes the connection.

The connection will not be dropped immediately: it will be dropped when there

is no more data traffic on the connection. So if a client needs to graciously

shutdown the connection, Close(), not Stop(), needs to be used after shutting

down the socket.

*/

	{

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

	CloseSubSession(ECNClose);

	}

EXPORT_C void RConnection::Start(TRequestStatus& aStatus)

/** Start a connection asynchonously using the default connection preferences.

The request completes once the connection is fully up or an error has occurred.

Successful completion will be accompanied by a KConnectionUp progress. 

If an RConnection has been stopped or has gone down, any subsequent start will

act in the same way as a start with a new RConnection. i.e. The preferences from

previous starts will not be used.

@param aStatus On return, the status of the request, e.g. KErrNone, KErrAlreadyExists.

@capability Dependent on the access point implementation */

	{

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

	SendReceive(ECNStart, TIpcArgs(), aStatus);

	}

EXPORT_C void RConnection::Start(TConnPref& aPref, TRequestStatus& aStatus)

/** Start a connection asynchonously using the connection preferences specified.

The connection preferences can be of type TConnSnapPref, TCommDbConnPref,

TCommDbMultiConnPref or TConnPrefList. See the definitions of these classes to see

their usage. 

The request completes once the connection is fully up or an error has occurred.

Successful completion will be accompanied by a KConnectionUp progress. 

If an RConnection has been stopped or has gone down, any subsequent start will

act in the same way as a start with a new RConnection. i.e. The preferences from

previous starts will not be used.

@see TConnSnapPref

@see TCommDbConnPref

@see TCommDbMultiConnPref

@see TConnPrefList

@param aPref Connection preferences.

@param aStatus On return, the status of the request, e.g. KErrNone, KErrAlreadyExists.

@capability Dependent on the access point implementation */

	{

	LOG( ESockLog::Printf(_L8("RConnection %08x:\tStart() with preferences, tid %d"), this, (TUint)RThread().Id()));

	if (aPref.ExtensionId() != TConnPref::EConnPrefEComList)

		{

		SendReceive(ECNSetStartPrefs, TIpcArgs(&aPref));

		}

	else

		{

		TConnPrefList& custPref = static_cast<TConnPrefList&>(aPref);

		RBuf8 prefFlatteningBuffer;

		TInt err = prefFlatteningBuffer.Create(custPref.Length());

        if (err == KErrNone)

            {

            err = custPref.Store(prefFlatteningBuffer);

            }

        if (err != KErrNone)

            {

            prefFlatteningBuffer.Close();

            aStatus = err;

            return;

            }

        SendReceive(ECNSetStartPrefs, TIpcArgs(&prefFlatteningBuffer));

        prefFlatteningBuffer.Close();

		}

    SendReceive(ECNStart, TIpcArgs(), aStatus);

	}

EXPORT_C TInt RConnection::Start()

/** Start a connection synchonously using the default connection preferences.

The request completes once the connection is fully up or an error has occurred.

Successful completion will be accompanied by a KConnectionUp progress. 

If an RConnection has been stopped or has gone down, any subsequent start will

act in the same way as a start with a new RConnection. i.e. The preferences from

previous starts will not be used.

@return KErrNone if successful or the connection already exists, otherwise

another of the system wide error codes.

@capability Dependent on the access point implementation */

	{

	TRequestStatus status;

	Start(status);

	User::WaitForRequest(status);

	TInt ret = status.Int();

	if (ret == KErrAlreadyExists)

	    {

	    return KErrNone;

	    }

	return ret;

	}

EXPORT_C TInt RConnection::Start(TConnPref& aPref)

/** Start a connection synchonously using the connection preferences specified.

The connection preferences can be of type TConnSnapPref, TCommDbConnPref,

TCommDbMultiConnPref or TConnPrefList. See the definitions of these classes to see

their usage. 

The request completes once the connection is fully up or an error has occurred.

Successful completion will be accompanied by a KConnectionUp progress. 

If an RConnection has been stopped or has gone down, any subsequent start will

act in the same way as a start with a new RConnection. i.e. The preferences from

previous starts will not be used.

@see TConnSnapPref

@see TCommDbConnPref

@see TCommDbMultiConnPref

@see TConnPrefList

@param aPref Connection preferences.

@return KErrNone if successful or the connection already exists, otherwise

another of the system wide error codes.

@capability Dependent on the access point implementation */

	{

	TRequestStatus status;

	Start(aPref, status);

	User::WaitForRequest(status);

	TInt ret = status.Int();

    if (ret == KErrAlreadyExists)

        {

        return KErrNone;

        }

	return ret;

	}

EXPORT_C TInt RConnection::Stop()

/** Stops the entire connection by disconnecting the underlying network interface

immediately, regardless of whether other clients are using it or not.

Applications using the connection will be sent the socket error code KErrCancel.

The application generally responds with clean up operations and pop-up boxes

alerting the user to the termination of the application.

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

codes. */

	{

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

	return Stop(EStopNormal);

	}

EXPORT_C TInt RConnection::Stop(TConnStopType aStopType)

/** Stops the entire connection by disconnecting the underlying network interface

immediately, regardless of whether other clients are using it or not.

If the argument is EStopNormal this is identical to calling Stop() with no

argument. If it is EStopAuthoritative then applications using the connection

will be sent the socket error code KErrConnectionTerminated, which generally

results in the applications closing quietly (without pop-up boxes).

@param aStopType The type of stop which is being requested.

@return KErrNone or another of the system wide error codes; in particular KErrArgument

if the stop type is unrecognised. */

    {

	LOG( ESockLog::Printf(_L8("RConnection %08x:\tStop(TConnStopType = %d) tid %d"), this, aStopType, (TUint)RThread().Id()));

	return SendReceive(ECNStop, TIpcArgs(aStopType));

    }

EXPORT_C TInt RConnection::Stop(TSubConnectionUniqueId aSubConnectionUniqueId)

/** Stops a subconnection.

Applications will be sent a socket error code to indicate that they must perform

clean up operations.

@publishedPartner

@released since v7.0s

@pre An attached connection: as a result of performing either a Start() or an Attach()

@param aSubConnectionUniqueId A valid identifier for a subconnection.

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

codes. */

	{

	LOG( ESockLog::Printf(_L8("RConnection %08x:\tStop(TSubConnectionUniqueId = %d) tid %d"), this, aSubConnectionUniqueId, (TUint)RThread().Id()));

	return Stop(aSubConnectionUniqueId, EStopNormal);

	}

EXPORT_C TInt RConnection::Stop(TSubConnectionUniqueId aSubConnectionUniqueId, TConnStopType aStopType)

/**

 * Stop a subconnection on an interface

 *

 * @publishedPartner

 * @released since v7.0s

 * @pre Must be attached to a connection; either by performing a Start(), or using Attach()

 * @param aSubConnectionUniqueId A valid identifier for a subconnection

 * @param aStopType The kind of stop to do (controls what error code is reported to interface clients)

 * @return KErrNone if successful, otherwise one of the system-wide error codes

 */

	{

	LOG( ESockLog::Printf(_L8("RConnection %08x:\tStop(TSubConnectionUniqueId = %d, TConnStopType = %d) tid %d"), this, aSubConnectionUniqueId, aStopType, (TUint)RThread().Id()));

	return SendReceive(ESCPSStop, TIpcArgs(aSubConnectionUniqueId, aStopType));

	}

EXPORT_C TInt RConnection::WaitForIncoming(RSubConnection& aIncomingSubConnection)

/**

 * Synchronously wait for an incoming session on this connection.

 *

 * @publishedPartner

 * @released since v9.2

 * @pre Must be attached to a connection by performing a Start().

 * @param aStatus On completion, the status of the request, e.g. KErrNone or another of the system wide error codes.

 * @param aIncomingSubConnection On completion, the subconnection representing the incoming session.

 * The incoming session can be accepted (by calling RSubConnection::Accept) or rejected (by calling RSubConnection::Stop)

 * The subconnection is implicitly started (no need to call RSubConnection::Start). aIncomingSubConnection must not

 * be open prior to calling this method.

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

 */

	{

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

	TRequestStatus status;

	WaitForIncoming(aIncomingSubConnection, status);

	User::WaitForRequest(status);

	return status.Int();

	}

EXPORT_C void RConnection::WaitForIncoming(RSubConnection& aIncomingSubConnection, TRequestStatus& aStatus)

/**

 * Subscribe for an incoming session on this connection.

 *

 * @publishedPartner

 * @released since v9.2

 * @pre Must be attached to a connection by performing a Start().

 * @param aStatus On completion, the status of the request, e.g. KErrNone or another of the system wide error codes.

 * @param aIncomingSubConnection On completion, the subconnection representing the incoming session.

 * The incoming session can be accepted (by calling RSubConnection::Accept) or rejected (by calling RSubConnection::Stop)

 * The subconnection is implicitly started (no need to call RSubConnection::Start). aIncomingSubConnection must not

 * be open prior to calling this method.

 */

	{

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

	//============================================================================================================

	//TODO: The statement below is really awkward and it is so, because we do not store the handle to the RSocketServ

	//anywhere here. For the same reason we need to call RSubConnection::Open against _both_ RSocketServ and

	//RConnection although RConnection has just been opened against the same RSocketServ.

	//There's nothing except BC that's stopping us from doing the following changes:

	//(1) store RSocketServ in RSubSessionBase so that it can be reused.

	//(2) change APIs like RSubConnection::Open(RSocketServ& aServer, TSubConnType aSubConnType, RConnection& aConnection)

	//                  to RSubConnection::Open(TSubConnType aSubConnType, RConnection& aConnection)

	//============================================================================================================

	const RSessionBase sessionBase = Session();

	TInt error = aIncomingSubConnection.Open(

	    const_cast<RSocketServ&>(static_cast<const RSocketServ&>(sessionBase)), TSubConnOpen::EWaitForIncoming, *this );

	if (error != KErrNone)

    	{

    	TRequestStatus* statusPtr = &aStatus;

    	User::RequestComplete(statusPtr, KErrArgument);

    	return;

    	}

	SendReceive(ECNWaitForIncoming, TIpcArgs(aIncomingSubConnection.SubSessionHandle()), aStatus);

	}

EXPORT_C void RConnection::CancelWaitForIncoming()

/**

 * Cancel the previous subscription for an incoming session.

 *

 * @publishedPartner

 * @released since v9.2

 * @see WaitForIncoming()

 * @pre Must be attached to a connection by performing a Start().

 */

	{

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

	SendReceive(ECNCancelWaitForIncoming, TIpcArgs());

	}

EXPORT_C void RConnection::ProgressNotification(TNifProgressBuf& aProgress, TRequestStatus& aStatus, TUint aSelectedProgress)

/** Requests asynchronous progress notification for the connection.

@param aProgress A buffer to receive progress notification.

@param aStatus On return, the status of the request.

@param aSelectedProgress The type of progress to report. If set, report only

the particular progress specified and any progress in error. If not set, report

all progress normally. */

	{

	SendReceive(ECNProgressNotification, TIpcArgs(&aProgress,aSelectedProgress ), aStatus);

	}

EXPORT_C void RConnection::ProgressNotification(TSubConnectionUniqueId aSubConnectionUniqueId, TNifProgressBuf& aProgress, TRequestStatus& aStatus, TUint aSelectedProgress)

/** Requests asynchronous progress notification for a subconnection.

NOTE: This function is not supported and will correctly return KErrNotSupported.

@publishedPartner

@released since v7.0s

@pre An attached connection: as a result of performing either a Start() or an Attach()

@pre No outstanding request for progress notifications for this subconnection on

this RConnection

@param aSubConnectionUniqueId A valid identifier for a subconnection.

@param aProgress A buffer to receive progress notification.

@param aStatus On return, the status of the request.

@param aSelectedProgress The type of progress to report. If set, report only

the particular progress specified and any progress in error. If not set, report

all progress normally.

*/

	{

	SendReceive(ESCPSProgressNotification, TIpcArgs(aSubConnectionUniqueId, &aProgress, aSelectedProgress), aStatus);

	}

EXPORT_C void RConnection::CancelProgressNotification()

/** Cancels a request for progress notification for the connection, as issued by

ProgressNotification().

*/

	{

	SendReceive(ECNCancelProgressNotification, TIpcArgs());

	}

EXPORT_C void RConnection::CancelProgressNotification(TSubConnectionUniqueId aSubConnectionUniqueId)

/** Cancels a request for progress notification for a specified subconnection,

as issued by ProgressNotification().

@publishedPartner

@released since v7.0s

@pre An attached connection: as a result of performing either a Start() or an Attach()

@pre An outstanding request for a progress notification on the subconnection on

this RConnection

@param aSubConnectionUniqueId The identifier for the subconnection used to make the request.

*/

	{

	SendReceive(ESCPSCancelProgressNotification, TIpcArgs(aSubConnectionUniqueId));

	}

EXPORT_C TInt RConnection::Progress(TNifProgress& aProgress)

/** Obtains the current progress information for the connection.

@param aProgress A buffer to receive progress information.

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

codes. */

	{

	TPckg<TNifProgress> prog(aProgress);

	return SendReceive(ECNProgress, TIpcArgs(&prog));

	}

EXPORT_C TInt RConnection::Progress(TSubConnectionUniqueId aSubConnectionUniqueId, TNifProgress& aProgress)

/** Obtains the current progress information on a specified subconnection.

@publishedPartner

@released since v7.0s

@pre An attached connection: as a result of performing either a Start() or an Attach()

@param aSubConnectionUniqueId A valid identifier for the subconnection of

interest.

@param aProgress On return, progress information.

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

codes. */

	{

	TPckg<TNifProgress> prog(aProgress);

	return SendReceive(ESCPSProgress, TIpcArgs(aSubConnectionUniqueId, &prog));

	}

EXPORT_C TInt RConnection::LastProgressError(TNifProgress& aProgress)

/** Obtains information about the last Progress() call which failed with an error.

@param aProgress A buffer to receive progress information.

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

codes. */

	{

	TPckg<TNifProgress> prog(aProgress);

	return SendReceive(ECNLastProgressError, TIpcArgs(&prog));

	}

EXPORT_C void RConnection::ServiceChangeNotification(TUint32& aNewISPId, TDes& aNewServiceType, TRequestStatus& aStatus)

/** 

 * Requests service change notification from the agent.

 * This call completes if the underlying service changes (i.e. ISP, GPRS APN

 * or LAN Service).

 * Important: It Panics if used BEFORE "RConnecion::Open(...)" being called.

 * 

 * @param aNewISPId On completion, the new ISP Id.

 * @param aNewServiceType On completion, the new service type.

 * @param aStatus On completion, "KErrNone" if succesful, "KErrNotReady" if

 * 		called before "RConnection::Start(...)" being called, "KErrInUse" if

 * 		called twice. Otherwise another of the system wide error codes. */

	{

	(void) ::new(&iNewISPId) TPckg<TUint32>(aNewISPId);

	SendReceive(ECNServiceChangeNotification, TIpcArgs(&iNewISPId,&aNewServiceType ), aStatus);

	}

EXPORT_C void RConnection::CancelServiceChangeNotification()

/**

 * Cancels a request for notification of change of service for the connection,

 * as issued by ServiceChangeNotification().

 * Nothing happens if called without having 

 * called "RConnection::ServiceChangeNotification(...)" before.

 * Important: It Panics if used BEFORE "RConnecion::Open(...)" being called. */

	{

	SendReceive(ECNCancelServiceChangeNotification,TIpcArgs()); // Ignore return value

	}

EXPORT_C TInt RConnection::GetIntSetting(const TDesC& aSettingName, TUint32& aValue)

//

// Get "active setting", i.e. the current default

// or override, for the specified database field

//

/** Reads current CommDb settings for the active connection.

@pre An attached connection: as a result of performing either a Start() or an Attach()

@param aSettingName The CommDb table name and field name to be accessed. Of

the form "<table name>\<field name>" (for example "IAP\Id" or "ModemBearer\PortName").

@param aValue On return, the value of the table/field pair.

@return KErrNone if succesful, or another of the system-wide error codes.

@capability Dependent on table - deferred to RDBMS

@deprecated Since 9.5 - For replacement functionality see GetParameters

*/

	{

	TPckg<TUint32> intPckg(aValue);

	return SendReceive(ECNGetIntSetting, TIpcArgs(&aSettingName,&intPckg ));

	}

EXPORT_C TInt RConnection::GetBoolSetting(const TDesC& aSettingName, TBool& aValue)

//

// Get "active setting", i.e. the current default

// or override, for the specified database field

//

/** Reads current CommDb settings for the active connection.

@pre An attached connection: as a result of performing either a Start() or an Attach()

@param aSettingName The CommDb table name and field name to be accessed. Of

the form "<table name>\<field name>". (for example "IAP\Id" or "ModemBearer\PortName").

@param aValue On return, the value of the table/field pair.

@return KErrNone if succesful, or another of the system-wide error codes.

@capability Dependent on table - deferred to RDBMS

@deprecated Since 9.5 - For replacement functionality see GetParameters

*/

	{

	TPckg<TBool> boolPckg(aValue);

	return SendReceive(ECNGetBoolSetting, TIpcArgs(&aSettingName,&boolPckg ));

	}