// wsp_socket.h

// 

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

//

#ifndef __WSP_SOCKET_H__

#define __WSP_SOCKET_H__

#include <winsock2.h>

#include "wsp_subsession.h"

class RWin32Factory;

class TInetAddr;

class RWin32Socket : public RWin32SubSession

	{

public:

	enum TType

		{

		EBlank,

		ETcp,

		EUdp

		};

public:

	TInt Open(RWin32Factory& aFactory, TType aType);

	void Close();

	TInt Connect(const TInetAddr& aAddress, TRequestStatus& aStatus);

	void CancelConnect();

	TInt Send(const TDesC8& aSendBuffer, TRequestStatus& aStatus);

	void CancelSend();

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

	void CancelSendTo();

	TInt Receive(TDes8& aReceiveBuffer, TRequestStatus& aStatus);

	void CancelReceive();

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

	void CancelReceiveFrom();

	TInt GetSocketName(TInetAddr& aAddress) const;

	TInt GetPeerName(TInetAddr& aAddress) const;

	TInt Bind(const TInetAddr& aAddress);

	TInt Listen(TUint aQueueSize);

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

	void CancelAccept();

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

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

	};

class CWin32Socket : public CWin32SubSession

	{

public:

	enum TOppCode

		{

		EConnect,

		ECancelConnect,

		ESend,

		ECancelSend,

		ESendTo,

		ECancelSendTo,

		EReceive,

		ECancelReceive,

		EReceiveFrom,

		ECancelReceiveFrom,

		EGetSocketName,

		EBind,

		EGetPeerName,

		EListen,

		EAccept,

		ECancelAccept,

		EGetOption,

		ESetOption

		};

public:

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

	virtual ~CWin32Socket();

private: // From CWin32ActiveObject.

	virtual void Run();

private: // From CWin32SubSession.

	virtual void ServiceL(TWin32Message& aMessage);

private:

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

	void ConstructL();

	void Connect(TWin32Message& aMessage);

	void Send(TWin32Message& aMessage);

	void SendTo(TWin32Message& aMessage);

	void Receive(TWin32Message& aMessage);

	void ReceiveFrom(TWin32Message& aMessage);

	void GetSocketName(TWin32Message& aMessage) const;

	void Bind(TWin32Message& aMessage);

	void GetPeerName(TWin32Message& aMessage) const;

	void Listen(TWin32Message& aMessage);

	void Accept(TWin32Message& aMessage);

	void GetOption(TWin32Message& aMessage) const;

	void SetOption(TWin32Message& aMessage);

	void DoSend();

	void CloseSocket();

	void HandleConnectionComplete(TInt aError);

	void HandleAcceptReady(TInt aError);

	static void CALLBACK SendCompletion(DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags);

	static void CALLBACK SendToCompletion(DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags);

	static void CALLBACK ReceiveCompletion(DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags);

	static void CALLBACK ReceiveFromCompletion(DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags);

	void ConvertAddress(const TInetAddr& aESockAddress, SOCKADDR_IN& aWinSockAddress) const;

	void ConvertAddress(const SOCKADDR_IN& aWinSockAddress, TInetAddr& aESockAddress) const;

private:

	RWin32Socket::TType iType;

	SOCKET iSocket;

	unsigned long iFlags;

	WSABUF iSendBuffer;

	WSABUF iReceiveBuffer;

	WSAOVERLAPPED iSendOverlapped;

	WSAOVERLAPPED iReceiveOverlapped;

	SOCKADDR_IN iReceiveFromAddress;

	TInt iReceiveFromAddressLength;

	TInetAddr* iReceiveFromClientAddress;

	TInt iBytesSent;

	TWin32Message* iConnectMessage;

	TWin32Message* iSendMessage;

	TWin32Message* iReceiveMessage;

	TWin32Message* iAcceptMessage;

	CWin32Socket* iBlankAcceptSocket;

	};

class MWin32SocketObserver

	{

public:

	enum TRequestType

		{

		ENone,

		EConnect,

		ESend,

		ESendTo,

		EReceive,

		EReceiveFrom,

		EAccept

		};

public:

	virtual void HandleWin32SocketCompletion(TRequestType aRequestType, TInt aError) = 0;

	};

class CWin32SocketWrapper : public CActive

	{

public:

	static CWin32SocketWrapper* NewL(MWin32SocketObserver& aObserver, RWin32Socket& aWin32Socket);

	~CWin32SocketWrapper();

	TInt Connect(const TInetAddr& aAddress);

	TInt Send(const TDesC8& aSendBuffer);

	TInt SendTo(const TDesC8& aSendBuffer, const TInetAddr& aAddress);

	TInt Receive(TDes8& aReceiveBuffer);

	TInt ReceiveFrom(TDes8& aReceiveBuffer, TInetAddr& aAddress);

	TInt Accept(RWin32Socket& aNewSocket);

private: // From CActive.

	virtual void DoCancel();

	virtual void RunL();

	virtual TInt RunError(TInt aError);

public:

	CWin32SocketWrapper(MWin32SocketObserver& aObserver, RWin32Socket& aWin32Socket);

	void ConstructL();

private:

	MWin32SocketObserver& iObserver;

	RWin32Socket iWin32Socket; // Shallow copy to give each a unique TWin32Message object.

	MWin32SocketObserver::TRequestType iRequestType;

	};

#endif // __WSP_SOCKET_H__