// 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 "csocket.h"
#include "chttpsecuresocket.h"
#include "mcommsinfoprovider.h"
#include "thttptrlayerpanic.h"

#include  <http/rhttpconnectioninfo.h>
#include <httpsocketconstants.h>
#include <in6_opt.h> 

const TInt KDefaultFlags		= 0;
const TInt KTcpTriggeredKeepAlive	= 2;
const TInt KSocketRecvBufSize = 16 * 1024;
const TInt KSocketSendBufSize = 16 * 1024;
const TInt KSocketDefaultSendBufSize = 4 * 1024;

const TUint32 TSoTcpLingerinMicroSec = 0x101F55F6;//linger constant to send close connection fast


CSocket* CSocket::NewL(MCommsInfoProvider& aCommsInfoProvider, TSocketType aSocketType)
/**	
	The factory constructor.
	@param		aCommsInfoProvider	The comms info provider object.
	@param		aSocketType			The type of the socket.
	@return		A pointer to a fully constructed object.
*/
	{
	CSocket* self = new (ELeave) CSocket(aCommsInfoProvider);
	CleanupStack::PushL(self);
	self->ConstructL(aSocketType);
	CleanupStack::Pop(self);
	return self;
	}

CSocket* CSocket::New(MCommsInfoProvider& aCommsInfoProvider, TSocketType aSocketType)
    {
    CSocket* self = new CSocket(aCommsInfoProvider);
    if(self)
        {
        TInt error = self->Construct(aSocketType);
        if(error != KErrNone)
            {
            delete self;
            self = NULL;
            }
        }
    return self;
    }

CSocket::~CSocket()
/**
	Destructor.
*/
	{
	// Close socket and notify the socket status observer
	if( iSecureSocketController )
		delete iSecureSocketController;
	else
		iSocket.Close();
	}

CSocket::CSocket(MCommsInfoProvider& aCommsInfoProvider)
: CBase(), iCommsInfoProvider(aCommsInfoProvider)
/**	
	Constructor.
	@param		aCommsInfoProvider	The comms info provider object.
*/
	{
	}

void CSocket::ConstructL(TSocketType aSocketType)
/**	
	Second phase constructor.
	@param		aSocketType	The type of the socket.
*/
	{
    User::LeaveIfError(Construct(aSocketType));
	}

TInt CSocket::Construct(TSocketType aSocketType)
    {
    TInt error = KErrNone;
    switch( aSocketType )
        {
    case EProtocolSocket:
        {
        if ( iCommsInfoProvider.HasConnection() )
            {
            // Open a protocol socket with a RConnection
            error = iSocket.Open(iCommsInfoProvider.SocketServer(),
                                 iCommsInfoProvider.ProtocolDescription().iAddrFamily, 
                                 iCommsInfoProvider.ProtocolDescription().iSockType, 
                                 iCommsInfoProvider.ProtocolDescription().iProtocol,
                                 iCommsInfoProvider.Connection()
                                 );              
            }
        else
            {
            // Open a protocol socket without a RConnection, we don't need one ( Loopback address )
            error = iSocket.Open(iCommsInfoProvider.SocketServer(),
                                 iCommsInfoProvider.ProtocolDescription().iAddrFamily, 
                                 iCommsInfoProvider.ProtocolDescription().iSockType, 
                                 iCommsInfoProvider.ProtocolDescription().iProtocol
                                 );                                          
            }
        } break;
    case EBlankSocket:
        {
        // Open a blank socket
        error = iSocket.Open(iCommsInfoProvider.SocketServer());
        } break;
    default:
        User::Invariant();
        }
    if(error == KErrNone)
        {
        TInt id = iCommsInfoProvider.SessionId();
        if(id>=0) 
            {
            // set socket option
            iSocket.SetOpt(KSOHttpSessionId, KSOLHttpSessionInfo, id);
            iSocket.SetOpt(KSoTcpKeepAlive, KSolInetTcp, KTcpTriggeredKeepAlive);
            }
        if(aSocketType != EBlankSocket)
            {
            iSocket.SetOpt(KSoTcpNoDelay,KSolInetTcp,1);  // Disable the nagle.
            iSocket.SetOpt(KSORecvBuf, KSOLSocket, KSocketRecvBufSize); // Set the socket recv buf to be 16K
            }
        TInt lingerTimeout = iCommsInfoProvider.GetSocketImmediateCloseTimeout();
        if (lingerTimeout != KErrNotFound)
            {
            TPckgBuf<TSoTcpLingerOpt> linger;
            linger().iOnOff  = 1;
            linger().iLinger =  lingerTimeout;
            iSocket.SetOpt(TSoTcpLingerinMicroSec, KSolInetTcp, linger);
            }
        }
    return error;
    }

TInt CSocket::Listen(TUint aQSize, TUint16 aPort)
/**	
	Start the listen service. The socket is bound to the local port specified by
	aPort. The listen service is then started. The aQSize argument specifies the
	number of connections that can be received simultaneously, awaiting to be 
	accepted.
	@param		aQSize		The length of the listening queue.
	@param		aPort		The local port number on which to listen.
	@return		A value of KErrNone if the listen service was successfully 
				started.
*/
	{
	// Bind the socket to the port
	TSockAddr addr;
	addr.SetPort(aPort);

	TInt error = iSocket.Bind(addr);

	if( error == KErrNone )
		{
		// Start the listening service
		error = iSocket.Listen(aQSize);
		}
	return error;
	}

void CSocket::Accept(CSocket& aBlankSocket, TRequestStatus& aStatus)
/**	
	Start asynchronous accept service. The socket should have had the listening
	service started. When a connection has been received, the blank socket will
	be given the connection. The request status is completed either when a 
	connection is received or an error has occured - this is reflected in the 
	value of the request status.
	@param		aBlankSocket	The blank socket which will be given the 
								connection if one is received.
	@param		aStatus			The request status that is completed when the
								accept service completes.
*/
	{
	if( iSecureSocketController )
		{
		// Secure socket do not support secure listening
		aStatus=KRequestPending;
		TRequestStatus* pStat = &aStatus;
		User::RequestComplete(pStat, KErrNotSupported);
		}
	else
		iSocket.Accept(aBlankSocket.iSocket, aStatus);
	}

void CSocket::CancelAccept()
/**	
	Cancel the accept service.
*/
	{
	iSocket.CancelAccept();
	}

void CSocket::Connect(TInetAddr& aAddr, TRequestStatus& aStatus)
/**	
	Start asynchronous connect service. The address contains the IP address and
	port with which a tcp connection should be established with. The request 
	status is completed either when a connection has been established or an error
	has occurred - this is reflected in the value of the request status.
	@param		aAddr	The IP address and port of the remote host.
	@param		aStatus	The request status that is completed when the connect 
						service completes.
*/
	{
	iSocket.Connect(aAddr, aStatus);
	}

void CSocket::CancelConnect()
/**	
	Cancel the connect service.
*/
	{
	iSocket.CancelConnect();
	}

void CSocket::RecvOneOrMore(TDes8& aBuffer, TRequestStatus& aStatus)
/**	
	Receive data from socket asynchronously. Any data received by the socket is 
	placed in the buffer supplied by aBuffer. The request status is completed 
	either when data has been received or an error has occurred - this is 
	reflected in the value of the request status.
	@param		aBuffer	The buffer where any received data is placed.	
	@param		aStatus	The request status that is completed when the receive 
						service completes.
*/
	{
	if( iSecureSocketController )
		// aFlags not used for secure sockets
		iSecureSocketController->RecvOneOrMore(aBuffer, aStatus, iBytesReceived);
	else
		iSocket.RecvOneOrMore(aBuffer, KDefaultFlags, aStatus, iBytesReceived);
	}

void CSocket::CancelRecv()
/**	
	Cancel the receive service.
*/
	{
	if( iSecureSocketController )
		iSecureSocketController->CancelRecv();
	else
		iSocket.CancelRecv();
	}

void CSocket::Send(const TDesC8& aBuffer, TRequestStatus& aStatus)
/**	
	Send data to the socket asynchronously. The data in the supplied buffer is 
	sent to the socket. The request status is completed either when data has 
	been sent or an error has occurred - this is reflected in the value of the
	request status.
	@param		aBuffer	The buffer containing the data to be sent.
	@param		aStatus	The request status that is completed when the send 
						service completes.
*/
	{
	if( iSecureSocketController )
		iSecureSocketController->Send(aBuffer, aStatus);
	else
		iSocket.Write(aBuffer, aStatus);
	}

void CSocket::CancelSend()
/**	
	Cancel the send service.
*/
	{
	if( iSecureSocketController )
		iSecureSocketController->CancelSend();
	else
		iSocket.CancelWrite();
	}

void CSocket::Shutdown(TRequestStatus& aStatus)
/**	
	Shutdown the connection asynchronously. Any pending receive or send requests
	are allowed to complete before the connection is shutdown. The request 
	status is completed when either the connection has shutdown or an error has
	occurred - this is reflected in the value of the request status. This request
	cannot be cancelled. This method does not apply to secure connections. The
	request will complete with KErrNotSupported if used with a secure connection.
	@param		aStatus	The request status that is completed when the shutdown 
						service completes.
*/
	{
	if( iSecureSocketController )
		{
		// Not supported with secure connections
		aStatus=KRequestPending;
		TRequestStatus* pStat = &aStatus;
		User::RequestComplete(pStat, KErrNotSupported);
		}
	else
		iSocket.Shutdown(RSocket::ENormal, aStatus);
	}
	
void CSocket::ShutdownImmediate()
/**	
	Shutdown the connection synchronously. This method will shutdown the socket
	connection immediately using the abortive closing functionality. This method
	has no effect with secure connections.
*/
	{
	if( iSecureSocketController==NULL )
		{
		TRequestStatus shutdownStatus = KRequestPending;
		iSocket.Shutdown(RSocket::EImmediate, shutdownStatus);
		User::WaitForRequest(shutdownStatus);
		}
	}

void CSocket::RemoteName(TInetAddr& aAddr)
/**	
	Get the remote host name. The IP address and port of the remote host is set
	in the output argument.
	@param		aAddr	The output argument where the IP address and port of the
						remote host is placed.
*/
	{
	iSocket.RemoteName(aAddr);
	}

void CSocket::LocalName(TInetAddr& aAddr)
/**	
	Get the local socket name. The IP address and port of the local socket is 
	set in the output argument.
	@param		aAddr	The output argument where the IP address and port of the
						local socket is placed.
*/
	{
	iSocket.LocalName(aAddr);
	}

const CX509Certificate* CSocket::ServerCert()
 /**
 	Get the Server Certificate for this socket session.
	@return		A Certificate with the certificate information. This may be 
				NULL if the information is not available.
 */
 	{
 	if( iSecureSocketController )
		{
		return iSecureSocketController->ServerCert();
		}
	return NULL;
 	}
 	
	
TInt CSocket::CipherSuite(TDes8& aCipherSuite)
/**
	Get the current Cipher Suite for this socket session.
	@param		aCiptherSuite	A descriptor which will be filled with the cipher suite. 
								This is a 2 digit code as defined by RFC 2246. 
	@return		An error code. KErrNone on sucess. KErrNotSupported if this socket session is not secure.
*/
	{
	if (iSecureSocketController)
		return iSecureSocketController->CipherSuite(aCipherSuite);
	//else
	return KErrNotSupported;
	}

void CSocket::UpgradeToSecureL(TRequestStatus& aStatus, const TDesC8& aHostName,const TDesC& aProtocol)
/**
	Asynchronous request to upgrade the socket to a secure socket.
	@param	aStatus The request status, this will complete with KErrNone on the successful
					upgrade to a secure connection.
	@param	aHostName The host name of the server used for domain name checking
*/
	{
	// Check that the socket is already a secure one.
	if( iSecureSocketController )
		{
		// The socket connection is already secure, simply complete the request
		aStatus=KRequestPending;
		TRequestStatus* pStat = &aStatus;
		User::RequestComplete(pStat, KErrNone);
		}
	else
		{
		// Create the secure socket controller and start the secure handshake
		TRAPD(error, iSecureSocketController = CHttpSecureSocket::NewL(iSocket, iCommsInfoProvider));
		if (error == KErrNotFound || error == KEComErrNoInterfaceIdentified)
			User::Leave(KErrNotSupported);
		else if (error != KErrNone)
			User::Leave(error);
		iSecureSocketController->StartSecureHandshakeL(aStatus, aHostName,aProtocol);
		}
	}

void CSocket::CancelUpgradeToSecure()
/**
	Cancel the upgrade to a secure connection.
*/
	{
	if( iSecureSocketController )
		iSecureSocketController->CancelHandshake();
	}

TInt CSocket::PendingBytesToRead ()
	{
    if ( iSecureSocketController )
		    return iSecureSocketController->PendingBytesToRead ();
	TInt bytesToRead;
	TInt err = iSocket.GetOpt ( KSOReadBytesPending, KSOLSocket, bytesToRead );
	if ( err == KErrNone )
		return bytesToRead;
	return err;
	}
	
void CSocket::SetTCPCorking(TBool aValue)
    {
    if(aValue)
    	{
    	iSocket.SetOpt(KSoTcpNoDelay,KSolInetTcp,0);  // Disable the nagle.
      iSocket.SetOpt(KSOSendBuf, KSOLSocket, KSocketSendBufSize);
      }
    else
    	{
    	iSocket.SetOpt(KSoTcpNoDelay,KSolInetTcp,1);  // Disable the nagle.
      iSocket.SetOpt(KSOSendBuf, KSOLSocket, KSocketDefaultSendBufSize);        
      }
    
    iSocket.SetOpt(KSoTcpCork, KSolInetTcp, aValue);       
    
    }
