// wsp_socket.cpp

// 

// Copyright (c) 2002 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include <in_sock.h>

#include "wsp_socket.h"

#include "wsp_session.h"

#include "wsp_factory.h"

#include "wsp_panic.h"

#include "wsp_log.h"

#undef SetPort // Defined the Microsoft header "winspool.h".

#include <emulator.h>

//

// RWin32Socket.

//

TInt RWin32Socket::Open(RWin32Factory& aFactory, TType aType)

	{

	WSP_LOG(WspLog::Printf(_L("RWin32Socket::Open: aType: %d, this: 0x%x"), aType, this));

	TPckgC<TType> typePckg(aType);

	return CreateSubSession(aFactory, CWin32Factory::ENewSocket, typePckg);

	}

void RWin32Socket::Close()

	{

	WSP_LOG(WspLog::Printf(_L("RWin32Socket::Close: this: 0x%x"), this));

	RWin32SubSession::Close();

	}

TInt RWin32Socket::Connect(const TInetAddr& aAddress, TRequestStatus& aStatus)

	{

	WSP_LOG(WspLog::Printf(_L("RWin32Socket::Connect: this: 0x%x"), this));

	iWin32Message.Set(CWin32Socket::EConnect, aAddress, aStatus);

	return MakeRequest(iWin32Message);

	}

TInt RWin32Socket::Send(const TDesC8& aSendBuffer, TRequestStatus& aStatus)

	{

	WSP_LOG(WspLog::Printf(_L("RWin32Socket::Send: this: 0x%x, bytes to send: %d"), this, aSendBuffer.Length()));

	iWin32Message.Set(CWin32Socket::ESend, aSendBuffer, aStatus);

	return MakeRequest(iWin32Message);

	}

TInt RWin32Socket::SendTo(const TDesC8& aSendBuffer, const TInetAddr& aAddress, TRequestStatus& aStatus)

	{

	WSP_LOG(WspLog::Printf(_L("RWin32Socket::SendTo: this: 0x%x, bytes to send: %d"), this, aSendBuffer.Length()));

	TPtr8 addressPtr(const_cast<TUint8*>(aAddress.Ptr()), aAddress.Length(), aAddress.MaxLength()); // Slight hack - need to send two read buffers, but the framework doesn't support this, so send the address as a write buffer.

	iWin32Message.Set(CWin32Socket::ESendTo, aSendBuffer, addressPtr, aStatus);

	return MakeRequest(iWin32Message);

	}

TInt RWin32Socket::Receive(TDes8& aReceiveBuffer, TRequestStatus& aStatus)

	{

	WSP_LOG(WspLog::Printf(_L("RWin32Socket::Receive: this: 0x%x, bytes to receive: %d"), this, aReceiveBuffer.Length()));

	iWin32Message.Set(CWin32Socket::EReceive, aReceiveBuffer, aStatus);

	return MakeRequest(iWin32Message);

	}

TInt RWin32Socket::ReceiveFrom(TDes8& aReceiveBuffer, TInetAddr& aAddress, TRequestStatus& aStatus)

	{

	WSP_LOG(WspLog::Printf(_L("RWin32Socket::ReceiveFrom: this: 0x%x, bytes to receive: %d"), this, aReceiveBuffer.Length()));

	TPtrC8 addressPtr((TUint8*)&aAddress, 0); // Slight hack - need to send two write buffers, but the framework doesn't support this, so send the address as a read buffer.

	iWin32Message.Set(CWin32Socket::EReceiveFrom, addressPtr, aReceiveBuffer, aStatus);

	return MakeRequest(iWin32Message);

	}

void RWin32Socket::CancelConnect()

	{

	TWin32Message cancelWin32Message;

	cancelWin32Message.Set(CWin32Socket::ECancelConnect);

	MakeRequest(cancelWin32Message); // Throw away return code - can't do anything useful with it.

	}

void RWin32Socket::CancelSend()

	{

	TWin32Message cancelWin32Message;

	cancelWin32Message.Set(CWin32Socket::ECancelSend);

	MakeRequest(cancelWin32Message); // Throw away return code - can't do anything useful with it.

	}

void RWin32Socket::CancelSendTo()

	{

	TWin32Message cancelWin32Message;

	cancelWin32Message.Set(CWin32Socket::ECancelSendTo);

	MakeRequest(cancelWin32Message); // Throw away return code - can't do anything useful with it.

	}

void RWin32Socket::CancelReceive()

	{

	TWin32Message cancelWin32Message;

	cancelWin32Message.Set(CWin32Socket::ECancelReceive);

	MakeRequest(cancelWin32Message); // Throw away return code - can't do anything useful with it.

	}

void RWin32Socket::CancelReceiveFrom()

	{

	TWin32Message cancelWin32Message;

	cancelWin32Message.Set(CWin32Socket::ECancelReceiveFrom);

	MakeRequest(cancelWin32Message); // Throw away return code - can't do anything useful with it.

	}

TInt RWin32Socket::GetSocketName(TInetAddr& aAddress) const

	{

	WSP_LOG(WspLog::Printf(_L("RWin32Socket::GetSocketName: this: 0x%x"), this));

	TRequestStatus status;

	iWin32Message.Set(CWin32Socket::EGetSocketName, aAddress, status);

	TInt err = MakeRequest(iWin32Message);

	if (err)

		{

		return err;

		}

	else

		{

		User::WaitForRequest(status);

		return status.Int();

		}

	}

TInt RWin32Socket::Bind(const TInetAddr& aAddress)

	{

	WSP_LOG(WspLog::Printf(_L("RWin32Socket::Bind: this: 0x%x"), this));

	TRequestStatus status;

	iWin32Message.Set(CWin32Socket::EBind, aAddress, status);

	TInt err = MakeRequest(iWin32Message);

	if (err)

		{

		return err;

		}

	else

		{

		User::WaitForRequest(status);

		return status.Int();

		}

	}

TInt RWin32Socket::GetPeerName(TInetAddr& aAddress) const

	{

	WSP_LOG(WspLog::Printf(_L("RWin32Socket::GetPeerName: this: 0x%x"), this));

	TRequestStatus status;

	iWin32Message.Set(CWin32Socket::EGetPeerName, aAddress, status);

	TInt err = MakeRequest(iWin32Message);

	if (err)

		{

		return err;

		}

	else

		{

		User::WaitForRequest(status);

		return status.Int();

		}

	}

TInt RWin32Socket::Listen(TUint aQueueSize)

	{

	WSP_LOG(WspLog::Printf(_L("RWin32Socket::Listen: this: 0x%x"), this));

	TPckgC<TUint> queueSizePckg(aQueueSize);

	TRequestStatus status;

	iWin32Message.Set(CWin32Socket::EListen, queueSizePckg, status);

	TInt err = MakeRequest(iWin32Message);

	if (err)

		{

		return err;

		}

	else

		{

		User::WaitForRequest(status);

		return status.Int();

		}

	}

TInt RWin32Socket::Accept(RWin32Socket& aNewSocket, TRequestStatus& aStatus)

	{

	WSP_LOG(WspLog::Printf(_L("RWin32Socket::Accept: this: 0x%x"), this));

	TPckgC<TInt> newSocketHandlePckg(aNewSocket.iHandle);

	iWin32Message.Set(CWin32Socket::EAccept, newSocketHandlePckg, aStatus);

	return MakeRequest(iWin32Message);

	}

void RWin32Socket::CancelAccept()

	{

	TWin32Message cancelWin32Message;

	cancelWin32Message.Set(CWin32Socket::ECancelAccept);

	MakeRequest(cancelWin32Message); // Throw away return code - can't do anything useful with it.

	}

class TWin32SocketOptionsC

	{

public:

	TInt aLevel;

	TInt aName;

	const char* aValue;

	TInt aLength;

	};

class TWin32SocketOptions

	{

public:

	TInt aLevel;

	TInt aName;

	char* aValue;

	TInt* aLength;

	};

TInt RWin32Socket::GetOption(TInt aLevel, TInt aName, char* aValue, TInt* aLength) const

	{

	WSP_LOG(WspLog::Printf(_L("RWin32Socket::GetOption: this: 0x%x"), this));

	TWin32SocketOptions options = {aLevel, aName, aValue, aLength};

	TPckg<TWin32SocketOptions> optionsPckg(options);

	TRequestStatus status;

	iWin32Message.Set(CWin32Socket::EGetOption, optionsPckg, status);

	TInt err = MakeRequest(iWin32Message);

	if (err)

		{

		return err;

		}

	else

		{

		User::WaitForRequest(status);

		return status.Int();

		}

	}

TInt RWin32Socket::SetOption(TInt aLevel, TInt aName, const char* aValue, TInt aLength)

	{

	WSP_LOG(WspLog::Printf(_L("RWin32Socket::SetOption: this: 0x%x"), this));

	TWin32SocketOptionsC options = {aLevel, aName, aValue, aLength};

	TPckgC<TWin32SocketOptionsC> optionsPckg(options);

	TRequestStatus status;

	iWin32Message.Set(CWin32Socket::ESetOption, optionsPckg, status);

	TInt err = MakeRequest(iWin32Message);

	if (err)

		{

		return err;

		}

	else

		{

		User::WaitForRequest(status);

		return status.Int();

		}

	}

//

// CWin32Socket.

//

CWin32Socket* CWin32Socket::NewL(CWin32Scheduler& aScheduler, RWin32Socket::TType aType)

	{

	CWin32Socket* self = new(ELeave) CWin32Socket(aScheduler, aType);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CWin32Socket::CWin32Socket(CWin32Scheduler& aScheduler, RWin32Socket::TType aType)

	: CWin32SubSession(aScheduler), iType(aType)

	{

	}

void CWin32Socket::ConstructL()

	{

	CWin32SubSession::ConstructL();

	switch (iType)

		{

		case RWin32Socket::EBlank:

			{

			// Nothing to do.

			break;

			}

		case RWin32Socket::ETcp:

			{

			__ASSERT_DEBUG(iSocket == 0, Panic(EWinSockPrtCWin32SocketCreateSocketUnexpectedValidSocket));

			Emulator::Lock();

			iSocket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, NULL, WSA_FLAG_OVERLAPPED);

			Emulator::Unlock();

			if (iSocket == INVALID_SOCKET)

				{

				User::Leave(MapWinSockError(WSAGetLastError()));

				}

			break;

			}

		case RWin32Socket::EUdp:

			{

			__ASSERT_DEBUG(iSocket == 0, Panic(EWinSockPrtCWin32SocketCreateSocketUnexpectedValidSocket));

			Emulator::Lock();

			iSocket = WSASocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, NULL, WSA_FLAG_OVERLAPPED);

			Emulator::Unlock();

			if (iSocket == INVALID_SOCKET)

				{

				User::Leave(MapWinSockError(WSAGetLastError()));

				}

			break;

			}

		default:

			{

			__ASSERT_DEBUG(EFalse, Panic(EWinSockPrtCWin32SocketConstructLInvalidSocketType));

			}

		}

	}

CWin32Socket::~CWin32Socket()

	{

	CloseSocket();

	}

void CWin32Socket::ServiceL(TWin32Message& aMessage)

	{

	switch (aMessage.OppCode())

		{

		case EConnect:

			{

			Connect(aMessage);

			break;

			}

		case ECancelConnect:

			{

			if (iConnectMessage)

				{

				Complete(iConnectMessage, KErrCancel);

				}

			break;

			}

		case ESend:

			{

			Send(aMessage);

			break;

			}

		case ECancelSend:

			{

			if (iSendMessage)

				{

				Complete(iSendMessage, KErrCancel);

				}

			break;

			}

		case ESendTo:

			{

			SendTo(aMessage);

			break;

			}

		case ECancelSendTo:

			{

			if (iSendMessage)

				{

				Complete(iSendMessage, KErrCancel);

				}

			break;

			}

		case EReceive:

			{

			Receive(aMessage);

			break;

			}

		case ECancelReceive:

			{

			if (iReceiveMessage)

				{

				Complete(iReceiveMessage, KErrCancel);

				}

			break;

			}

		case EReceiveFrom:

			{

			ReceiveFrom(aMessage);

			break;

			}

		case ECancelReceiveFrom:

			{

			if (iReceiveMessage)

				{

				Complete(iReceiveMessage, KErrCancel);

				}

			break;

			}

		case EGetSocketName:

			{

			GetSocketName(aMessage);

			break;

			}

		case EBind:

			{

			Bind(aMessage);

			break;

			}

		case EGetPeerName:

			{

			GetPeerName(aMessage);

			break;

			}

		case EListen:

			{

			Listen(aMessage);

			break;

			}

		case EAccept:

			{

			Accept(aMessage);

			break;

			}

		case ECancelAccept:

			{

			if (iAcceptMessage)

				{

				Complete(iAcceptMessage, KErrCancel);

				}

			break;

			}

		case EGetOption:

			{

			GetOption(aMessage);

			break;

			}

		case ESetOption:

			{

			SetOption(aMessage);

			break;

			}

		default:

			{

			__ASSERT_DEBUG(EFalse, Panic(EWinSockPrtInvalidSocketOppCode));

			}

		}

	}

void CWin32Socket::Connect(TWin32Message& aMessage)

	{

	__ASSERT_DEBUG(iConnectMessage == NULL, Panic(EWinSockPrtCWin32SocketMultipleConnectRequests));

	iConnectMessage = &aMessage;

	WSP_LOG(WspLog::Printf(_L("CWin32Socket::Connect: this: 0x%x"), this));

	if (WSAEventSelect(iSocket, iEvent, FD_CONNECT) == SOCKET_ERROR)

		{

		TInt err = MapWinSockError(WSAGetLastError());

		CloseSocket();

		Complete(iConnectMessage, err);

		return;

		}

	const TInetAddr& address = static_cast<const TInetAddr&>(iConnectMessage->ReadBuffer());

	SOCKADDR_IN winSockAddress;

	ConvertAddress(address, winSockAddress);

	if (WSAConnect(iSocket, (LPSOCKADDR)&winSockAddress, sizeof(struct sockaddr_in), NULL, NULL, NULL, NULL) == SOCKET_ERROR)

		{

		TInt nError = WSAGetLastError();

		if (nError != WSAEWOULDBLOCK)

			{

			CloseSocket();

			Complete(iConnectMessage, MapWinSockError(nError));

			}

		}

	else

		{

		Complete(iConnectMessage, KErrNone);

		}

	}

void CWin32Socket::Send(TWin32Message& aMessage)

	{

	__ASSERT_DEBUG((iSendMessage == NULL) && (iBytesSent == 0), Panic(EWinSockPrtCWin32SocketMultipleSendRequests));

	iSendMessage = &aMessage;

	WSP_LOG(WspLog::Printf(_L("CWin32Socket::Send: this: 0x%x, bytes to send: %d"), this, iSendMessage->ReadBuffer().Length()));

	DoSend();

	}

void CWin32Socket::SendTo(TWin32Message& aMessage)

	{

	__ASSERT_DEBUG((iSendMessage == NULL) && (iBytesSent == 0), Panic(EWinSockPrtCWin32SocketMultipleSendToRequests));

	iSendMessage = &aMessage;

	WSP_LOG(WspLog::Printf(_L("CWin32Socket::SendTo: this: 0x%x, bytes to send: %d"), this, iSendMessage->ReadBuffer().Length()));

	TPtrC8 bufPtr(iSendMessage->ReadBuffer());

	iSendBuffer.buf = reinterpret_cast<char*>(const_cast<TUint8*>(bufPtr.Ptr()));

	iSendBuffer.len = bufPtr.Length();

	iSendOverlapped.hEvent = (void*) this;

	TInetAddr address;

	address.Copy(iSendMessage->WriteBuffer());

	SOCKADDR_IN winSockAddress;

	ConvertAddress(address, winSockAddress);

	DWORD numberOfBytesSent;

	TInt ret = WSASendTo(iSocket, &iSendBuffer, 1, &numberOfBytesSent, 0, (LPSOCKADDR)&winSockAddress, sizeof(struct sockaddr_in), &iSendOverlapped, &SendToCompletion);

	if (ret == SOCKET_ERROR)

		{

		TInt err = WSAGetLastError();

		if (err != WSA_IO_PENDING)

			{

			WSP_LOG(WspLog::Printf(_L("\tsocket error: %d"), err));

			Complete(iSendMessage, MapWinSockError(err));

			}

		}

	}

void CWin32Socket::Receive(TWin32Message& aMessage)

	{

	__ASSERT_DEBUG(iReceiveMessage == NULL, Panic(EWinSockPrtCWin32SocketMultipleReceiveRequests));

	iReceiveMessage = &aMessage;

	WSP_LOG(WspLog::Printf(_L("CWin32Socket::Receive: this: 0x%x, bytes to get: %d"), this, iReceiveMessage->WriteBuffer().MaxLength()));

	iReceiveBuffer.buf = reinterpret_cast<char*>(const_cast<TUint8*>(iReceiveMessage->WriteBuffer().Ptr()));

	iReceiveBuffer.len = iReceiveMessage->WriteBuffer().MaxLength();

	iFlags = 0;

	iReceiveOverlapped.hEvent = (void*) this;

	DWORD numberOfBytesReceived;

	TInt ret = WSARecv(iSocket, &iReceiveBuffer, 1, &numberOfBytesReceived, &iFlags, &iReceiveOverlapped, &ReceiveCompletion);

	if (ret == SOCKET_ERROR)

		{

		TInt err = WSAGetLastError();

		if (err != WSA_IO_PENDING)

			{

			WSP_LOG(WspLog::Printf(_L("\tsocket error: %d"), err));

			Complete(iReceiveMessage, MapWinSockError(err));

			}

		}

	}

void CWin32Socket::ReceiveFrom(TWin32Message& aMessage)

	{

	__ASSERT_DEBUG(iReceiveMessage == NULL, Panic(EWinSockPrtCWin32SocketMultipleReceiveFromRequests));

	iReceiveMessage = &aMessage;

	WSP_LOG(WspLog::Printf(_L("CWin32Socket::ReceiveFrom: this: 0x%x, bytes to get: %d"), this, iReceiveMessage->WriteBuffer().MaxLength()));