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

// Describes the implementation of a secure socket class.

// 

//

/**

 @file

*/

#include "SecureSocket.h"

#include "GenericSecureSocket.h"

#include <commsdattypesv1_1.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <ssl_internal.h>

#include <securesocket_internal.h>

#endif

#include <commsdattypeinfov1_1_internal.h>

#include <commsdattypesv1_1_partner.h>

using namespace CommsDat;

TInt SetTLSData(void);

#define LOADDLL_ORIG_ORDINAL 1

#define UNLOADDLL_ORDINAL 2

#define LOADDLL_NEW_ORDINAL 3

TSecSocketProtocol::~TSecSocketProtocol()

/** 

 * Closes the DLL library. 

 */

{

	iLibrary.Close();

}

TInt CSecureSocketLibraryLoader::OpenL(const TDesC& aProtocolName,TSecSockDllLibraryFunction& aEntryPoint)

/** 

 * Opens the protocol library.

 * Attempts to load the secure socket implementation DLL for the requested 

 * protocol type. 

 * 

 * @param aProtocolName	A reference to a descriptor containing the protocol name, 

 * 						i.e. tls1.0, ssl3.0. Case is ignored.

 * @param aEntryPoint	Entry point into the secureSocket plug-in.

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

 */

	{

	TLibraryFunction entry;

	CSecureSocketLibraryLoader::OpenWithIdL(LOADDLL_ORIG_ORDINAL, aProtocolName, entry);

	aEntryPoint = reinterpret_cast<TSecSockDllLibraryFunction>(entry);

	if(!aEntryPoint)

		{

		return KErrNotFound;

		}

	return KErrNone;

	}

TInt CSecureSocketLibraryLoader::OpenL(const TDesC& aProtocolName,TSecSockDllLibraryGenericFunction& aEntryPoint)

/** 

 * Opens the protocol library.

 * Attempts to load the secure socket implementation DLL for the requested 

 * protocol type. 

 * 

 * @param aProtocolName	A reference to a descriptor containing the protocol name, 

 * 						i.e. tls1.0, ssl3.0. Case is ignored.

 * @param aEntryPoint	Entry point into the secureSocket plug-in.

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

 */

	{

	TLibraryFunction entry;

	CSecureSocketLibraryLoader::OpenWithIdL(LOADDLL_NEW_ORDINAL, aProtocolName, entry);

	aEntryPoint = reinterpret_cast<TSecSockDllLibraryGenericFunction>(entry);

	if(!aEntryPoint)

		{

		return KErrNotFound;

		}

	return KErrNone;

	}

void CSecureSocketLibraryLoader::OpenWithIdL(TInt aId, const TDesC& aProtocolName, TLibraryFunction& aEntryPoint)

/** 

 * Opens the protocol library.

 * Attempts to load the secure socket implementation DLL for the requested 

 * protocol type. 

 * 

 * @param aProtocolName	A reference to a descriptor containing the protocol name, 

 * 						i.e. tls1.0, ssl3.0. Case is ignored.

 * @param aEntryPoint	Entry point into the secureSocket plug-in.

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

 */

{

	//Fetch the TLS data

	TSecureSocketGlobals* global = (TSecureSocketGlobals*)Dll::Tls();

	if ( !global )

	{

		if (SetTLSData() == KErrNone) 

			global = (TSecureSocketGlobals*)Dll::Tls();

	}

	__ASSERT_ALWAYS(global,User::Leave(KErrNoMemory));

	// Increase the globals use count

	global->iUseCount++;

	// Convert to lower case before doing a comparison

	TBuf<32> protocol;

	protocol.Copy(aProtocolName);

	protocol.LowerCase();

	//Walk the list and find the protocol

	global->iSecureSocketProtocolsIter.SetToFirst(); 

	TSecSocketProtocol* secProtocol;

	while ((secProtocol = global->iSecureSocketProtocolsIter++) != NULL)

		{

		if(secProtocol->iName.Compare(protocol))

			//Found a matching protocol name

			break;

		}

	if(secProtocol == NULL)

	//Library not loaded yet - Find a dll name in Commdb that matches proto name

	//and load the dll

		{

		secProtocol = new(ELeave)TSecSocketProtocol;

		CleanupStack::PushL(secProtocol);

		//Find the protocolname record in COMMDB

		TBuf<KMaxFileName> fileName;

		FindItemInDbL(protocol, fileName);

		// Load the library whose name we just fetched

		// Commented out the line below as it loads the SSLADAPTOR.DLL

		// Hardcoded the SSL.DLL. SSL.DLL ultimately should be an ECOM Plugin.

		// (These changes were made as part of GT167 Zephyr work on TLS.

		//(void)User::LeaveIfError(secProtocol->iLibrary.Load(fileName));

		(void)User::LeaveIfError(secProtocol->iLibrary.Load(_L("SSL.DLL")));

		//Add the entry in the list

		secProtocol->iName.Copy(protocol);

		global->iSecureSocketProtocols.AddLast(*secProtocol);

		CleanupStack::Pop();

		}

	// Get the pointer to the NewL function in the DLL

	aEntryPoint = secProtocol->iLibrary.Lookup(aId);	

}

void CSecureSocketLibraryLoader::FindItemInDbL(const TDesC& aProtocolName, TDes& aLibraryName)

/**

 * Opens the Commdb and locates the DLL name for a protocol.

 * 

 * @param aProtocolName	A reference to a descriptor containing the protocol name, 

 * 						i.e. tls1.0, ssl3.0. Case is ignored.

 * @param aLibraryName 	On return, name of the library.

 * @exception			This function will leave if the protocol was not found or in OOM conditions. 

 */

{

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

		CMDBSession* session = CMDBSession::NewL(KCDVersion1_2);

#else

		CMDBSession* session = CMDBSession::NewL(KCDVersion1_1);

#endif

		CleanupStack::PushL(session);

		CCDSecureSocketRecord* ptrRecord = static_cast<CCDSecureSocketRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdSSProtoRecord));

		CleanupStack::PushL(ptrRecord);

		ptrRecord->iSSProtoName = aProtocolName;

		// check if any record is returned back

		if (!ptrRecord->FindL(*session))

			{

			// ignore return from FindL otherwise tests fail

			//User::Leave(KErrNotFound);

			}

		aLibraryName = ptrRecord->iSSProtoLibrary;

		CleanupStack::PopAndDestroy(ptrRecord);

		CleanupStack::PopAndDestroy(session);

}

EXPORT_C void CSecureSocketLibraryLoader::Unload()

/** 

 * Closes and unloads the implementation library.

 */

{

	//Fetch the TLS data

	TSecureSocketGlobals* global = (TSecureSocketGlobals*)Dll::Tls();

	//Cannot assume that tls exists at this point (False with WINS)

	if(!global)

		return;

	// if the use count isn't 0, don't do the unload

	if ( --global->iUseCount )

		return;

	//Walk the list and find the protocol

	global->iSecureSocketProtocolsIter.SetToFirst(); 

	TSecSocketProtocol* secProtocol;

	while ((secProtocol = global->iSecureSocketProtocolsIter++) != NULL)

		{

		//Find the entry point for  the resource cleanup function 

		TSecSockDllUnloadFunction cleanupEntryPoint  = reinterpret_cast<TSecSockDllUnloadFunction> (secProtocol->iLibrary.Lookup(UNLOADDLL_ORDINAL));

		//Call the function

		if(cleanupEntryPoint)

			(*cleanupEntryPoint)(NULL);

		global->iSecureSocketProtocols.Remove(*secProtocol);

		delete secProtocol;

		}

	// remove the globals reference

	delete global;

	Dll::SetTls(NULL); // @bug check ret val

}

EXPORT_C CSecureSocket* CSecureSocket::NewL(RSocket& aSocket,const TDesC& aProtocol)

/** 

 * Creates and returns a pointer to a new secure socket.

 *

 * A reference to an already open and connected socket should be passed in, 

 * along with a descriptor that contains the protocol name.

 *

 * @param aSocket	A reference to an open and connected RSocket object.

 * @param aProtocol	A constant descriptor containing the protocol name.

 * @return 			A pointer to the newly created secure socket, or NULL if the creation failed.

 */

{

	CSecureSocket* self = new(ELeave) CSecureSocket;

	CleanupStack::PushL( self );

	self->ConstructL(aSocket,aProtocol);

	CleanupStack::Pop();

	return self;

}

EXPORT_C CSecureSocket* CSecureSocket::NewL(MGenericSecureSocket& aSocket,const TDesC& aProtocol)

/** 

 * Creates and returns a pointer to a new secure socket.

 *

 * A reference to a socket derived from MGenericSecureSocket should be passed in, 

 * along with a descriptor that contains the protocol name.

 *

 * @param aSocket	A reference to an MGenericSecureSocket derived object.

 * @param aProtocol	A constant descriptor containing the protocol name.

 * @return 			A pointer to the newly created secure socket, or NULL if the creation failed.

 */

{

	CSecureSocket* self = new(ELeave) CSecureSocket;

	CleanupStack::PushL( self );

	self->ConstructL(aSocket,aProtocol);

	CleanupStack::Pop();

	return self;

}

void CSecureSocket::ConstructL(RSocket& aSocket, const TDesC& aProtocol)

/** 

 * Standard 2-phase construction.

 */

{

	TSecSockDllLibraryFunction libEntryPointL;

	User::LeaveIfError(CSecureSocketLibraryLoader::OpenL(aProtocol,libEntryPointL));

	//Beware! the following call can leave...

	iSecureImplementation = (MSecureSocket*)libEntryPointL( aSocket, aProtocol );

	if (iSecureImplementation)

		{

		iSecureSocketState = ESecureSocketStateOpen;

		}

}

void CSecureSocket::ConstructL(MGenericSecureSocket& aSocket, const TDesC& aProtocol)

/** 

 * Standard 2-phase construction.

 */

{

	TSecSockDllLibraryGenericFunction libEntryPointL;

	User::LeaveIfError(CSecureSocketLibraryLoader::OpenL(aProtocol,libEntryPointL));

	//Beware! the following call can leave...

	iSecureImplementation = (MSecureSocket*)libEntryPointL( aSocket, aProtocol );

	if (iSecureImplementation)

		{

		iSecureSocketState = ESecureSocketStateOpen;

		}

}

CSecureSocket::~CSecureSocket()

/** 

 *Standard destructor. 

 */

{

	if ((iSecureImplementation) && (iSecureSocketState == ESecureSocketStateOpen))

	{

		iSecureImplementation->Close();

	}

	delete iSecureImplementation;

	// Close and unload the implementation library, Unload checks access count first

	CSecureSocketLibraryLoader::Unload();

}

//

EXPORT_C TInt CSecureSocket::AvailableCipherSuites( TDes8& aCiphers )

/** 

 * Gets the available cipher suites.

 *

 * Note that ciphersuites using NULL encryption or PSK key exchange will not be included

 * unless they have been enabled via SetOpt.

 *

 * @param aCiphers	Descriptor holding the ciphers.

 * @return			KErrNone if successful, a system-wide error code if not.

 */

{

	return iSecureImplementation->AvailableCipherSuites( aCiphers );

}

EXPORT_C void CSecureSocket::CancelAll()

/** 

 *Cancels all the send and receive actions in the SSL state machine. 

 */

{

	iSecureImplementation->CancelAll();

}

EXPORT_C void CSecureSocket::CancelHandshake()

/** 

 *Cancels the handshake. 

 */

{

	iSecureImplementation->CancelHandshake();

}

EXPORT_C void CSecureSocket::CancelRecv()

/** 

 * Cancels a receive action in the SSL state machine. 

 */

{

	iSecureImplementation->CancelRecv();

}

EXPORT_C void CSecureSocket::CancelSend()

/** 

 *Cancels a send action in the SSL state machine.

 */

{

	iSecureImplementation->CancelSend();

}

EXPORT_C const CX509Certificate* CSecureSocket::ClientCert()

/** 

 * Gets the current client certificate.

 * 

 * When a secure socket is acting in server mode, the returned certificate will 

 * be the certificate that the remote client provided. When acting in client mode, 

 * the certificate returned will be local certificate. 

 * 

 * @return	A pointer to the client certificate, or NULL if none exists. 

 */

{

	return iSecureImplementation->ClientCert();

}

EXPORT_C TClientCertMode CSecureSocket::ClientCertMode()

/** 

 * Gets the current client certificate mode.

 *

 * The client certificate mode is used when the socket is acting as a server, 

 * and determines whether a client certificate is requested. 

 *

 * @return	The current mode that is set. 

 */

{

	return iSecureImplementation->ClientCertMode();

}

EXPORT_C TDialogMode CSecureSocket::DialogMode()

/** 

 * Gets the current dialog mode. 

 * 

 * @return The current dialog mode.

 */

{

	return iSecureImplementation->DialogMode();

}

EXPORT_C void CSecureSocket::Close()

/** 

 * Closes the secure connection and the socket.

 *

 * Implementations should terminate the secure connection gracefully as 

 * appropriate to their protocol. The RSocket object is not destoyed: 

 * this is left to the client application. 

 */

{

	iSecureSocketState = ESecureSocketStateClosed;

	iSecureImplementation->Close();

}

EXPORT_C TInt CSecureSocket::CurrentCipherSuite( TDes8& aCipherSuite )

/** 

 * Gets the current cipher suite in use.

 * 

 * The current cipher suite is returned in the referenced buffer 

 * in two byte format as, i.e. [0x??][0x??].

 *

 * @param aCipherSuite	A reference to a descriptor at least 2 bytes long. 

 *						Implementations that differ from the [0x??][0x??] 

 *						format may require larger descriptors. See individual 

 *						implementation notes for details.

 * @return				KErrNone if successful; 

 *						otherwise, another of the system-wide error codes. 

 */

{

	return iSecureImplementation->CurrentCipherSuite( aCipherSuite );

}

EXPORT_C void CSecureSocket::FlushSessionCache()

/** 

 *Flushes the session cache. 

 */

{

	iSecureImplementation->FlushSessionCache();

}

EXPORT_C TInt CSecureSocket::GetOpt(TUint aOptionName, TUint aOptionLevel, TDes8& aOption)

/** 

 * Gets an option.

 *

 * Secure socket implementations may provide options that can 

 * be used with this function. 

 *

 * (nb. Getting the KSoServerNameIndication option is not supported).

 *

 * @param aOptionName	An integer constant which identifies an option. 

 * @param aOptionLevel	An integer constant which identifies the level of an option, 

 * 						i.e. an option level group of related options.

 * @param aOption		An option value packaged in a descriptor.

 * @return 				KErrNone if successful; 

 *						otherwise, another of the system-wide error codes. 

 */

{

	return iSecureImplementation->GetOpt(aOptionName, aOptionLevel, aOption);

}

EXPORT_C TInt CSecureSocket::GetOpt(TUint aOptionName, TUint aOptionLevel, TInt& aOption)

/** 

 * Gets an option.

 *

 * Secure socket implementations may provide options that can 

 * be used with this method. 

 *

 * (nb. Getting the KSoServerNameIndication option is not supported).

 *

 * @param aOptionName	An integer constant which identifies an option. 

 * @param aOptionLevel	An integer constant which identifies the level of an option, 

 * 						i.e. an option level group of related options.

 * @param aOption		An integer option value.

 * @return 				KErrNone if successful; 

 *						otherwise, another of the system-wide error codes. 

 */

{

	return iSecureImplementation->GetOpt(aOptionName, aOptionLevel, aOption);

}

EXPORT_C TInt CSecureSocket::Protocol(TDes& aProtocol)

/**

 * Gets the protocol in use.

 *

 * This method can be used to return the particular protocol/version that is 

 * being used by implementations that support different protocols/versions. 

 *

 * @param aProtocol	A descriptor containing the protocol name/version that is 

 *					being used. Protocol names can be up to 32 characters long, 

 *					and so a descriptor of at least that size is required.

 * @return			KErrNone 

 */

{

	return iSecureImplementation->Protocol( aProtocol );

}

EXPORT_C void CSecureSocket::Recv (TDes8& aDesc, TRequestStatus& aStatus )

/**

 * Receives data from the socket.

 *

 * This is an asynchronous function, and completes 

 * when the descriptor has been filled. Only one Recv() or RecvOneOrMore() 

 * operation can be outstanding at any time.

 *

 * @param aDesc		A descriptor where data read will be placed.

 * @param aStatus 	On completion, KErrNone if successful; 

 *					KErrEof if a remote connection is closed and there is no more data; 

 *					KErrNotReady if called when an operation is still outstanding; 

 *					or another system-wide error code. 

 */

{

	iSecureImplementation->Recv( aDesc, aStatus );

}

EXPORT_C void CSecureSocket::RecvOneOrMore( TDes8& aDesc, TRequestStatus& aStatus, TSockXfrLength& aLen )

/** 

 * Receives data from the socket.

 *

 * This is an asynchronous function, and will complete when at least one byte has been read. 

 * Only one Recv() or RecvOneOrMore() operation can be outstanding at any time.

 * 

 * @param aDesc		A descriptor where data read will be placed.

 * @param aStatus	On completion, KErrNone if successful;

 *					KErrEof if a remote connection is closed and there is no more data;

 * 					KErrNotReady if called when an operation is still outstanding;

 * 					or another system-wide error code.