// wsp_resolver.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 <winsock2.h>
// Prevent e32std.inl from failing to compile with "ambiguous access to overloaded function".
#define memmove _memmove
#define memset _memset
//
#include <e32math.h>
#include <in_sock.h>
#include <utf.h>
#include "wsp_resolver.h"
#include "wsp_session.h"
#include "wsp_factory.h"
#include "wsp_panic.h"
#include "wsp_log.h"


//
// Constants.
//

_LIT(KWspResolverWorkerThreadNameFormat, "WinSockPrtResolverWorkerThread_%x_%d");
const TInt  KWspResolverWorkerThreadNameLength =  64;
const TInt KWspResolverWorkerThreadStackSize = KDefaultStackSize;


//
// RWin32Socket.
//

RWin32Resolver::RWin32Resolver()
	: iNameRecordPckg(NULL, 0, 0)
	{
	}

TInt RWin32Resolver::Open(RWin32Factory& aFactory)
	{
	WSP_LOG(WspLog::Printf(_L("RWin32Resolver::Open: this: 0x%x"), this));
	return CreateSubSession(aFactory, CWin32Factory::ENewResolver);
	}

void RWin32Resolver::Close()
	{
	WSP_LOG(WspLog::Printf(_L("RWin32Resolver::Close: this: 0x%x"), this));
	RWin32SubSession::Close();
	}

TInt RWin32Resolver::GetByName(TNameRecord& aName, TRequestStatus& aStatus)
	{
	WSP_LOG(WspLog::Printf(_L("RWin32Resolver::GetByName: this: 0x%x"), this));
	iNameRecordPckg.Set(reinterpret_cast<TUint8*>(&aName), sizeof(TNameRecord),sizeof(TNameRecord));
	iWin32Message.Set(CWin32Resolver::EGetByName, iNameRecordPckg, aStatus);
	return MakeRequest(iWin32Message);
	}

TInt RWin32Resolver::GetByAddress(TNameRecord& aName, TRequestStatus& aStatus)
	{
	WSP_LOG(WspLog::Printf(_L("RWin32Resolver::GetByAddress: this: 0x%x"), this));
	iNameRecordPckg.Set(reinterpret_cast<TUint8*>(&aName), sizeof(TNameRecord),sizeof(TNameRecord));
	iWin32Message.Set(CWin32Resolver::EGetByAddress, iNameRecordPckg, aStatus);
	return MakeRequest(iWin32Message);
	}

void RWin32Resolver::Cancel()
	{
	WSP_LOG(WspLog::Printf(_L("RWin32Resolver::Cancel: this: 0x%x"), this));
	TWin32Message cancelWin32Message;
	cancelWin32Message.Set(CWin32Resolver::ECancel);
	MakeRequest(cancelWin32Message); // Throw away return code - can't do anything useful with it.
	}


//
// CWin32Resolver.
//

CWin32Resolver* CWin32Resolver::NewL(CWin32Scheduler& aScheduler)
	{
	CWin32Resolver* self = new(ELeave) CWin32Resolver(aScheduler);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CWin32Resolver::CWin32Resolver(CWin32Scheduler& aScheduler)
	: CWin32SubSession(aScheduler)
	{
	}

void CWin32Resolver::ConstructL()
	{
	CWin32SubSession::ConstructL();
	}

CWin32Resolver::~CWin32Resolver()
	{
	}

void CWin32Resolver::Run()
	{
	iMessage->Complete(iError);
	iMessage = NULL;
	iWorkerThread.Close();
	}

void CWin32Resolver::ServiceL(TWin32Message& aMessage)
	{
	switch (aMessage.OppCode())
		{
		case EGetByName:
		case EGetByAddress:
			{
			__ASSERT_DEBUG(iMessage == NULL, Panic(EWinSockPrtCWin32ResolverMultipleRequests));
			iMessage = &aMessage;
			CreateWorkerThread();
			break;
			}
		case ECancel:
			{
			Cancel();
			break;
			}
		default:
			{
			__ASSERT_DEBUG(EFalse, Panic(EWinSockPrtInvalidResolverOppCode));
			}
		}
	}

void CWin32Resolver::Cancel()
	{
	if (iWorkerThread.Handle() && (iWorkerThread.ExitType() == EExitPending))
		{
		iWorkerThread.Kill(KErrCancel);
		iMessage->Complete(KErrCancel);
		iMessage = NULL;
		iWorkerThread.Close();
		}
	}

void CWin32Resolver::CreateWorkerThread()
	{
	TBuf<KWspResolverWorkerThreadNameLength> threadName;
	threadName.Format(KWspResolverWorkerThreadNameFormat, this, Math::Rand(iRandSeed));
	TInt err = iWorkerThread.Create(threadName, WorkerThreadStart, KWspResolverWorkerThreadStackSize, NULL, this, EOwnerThread);
	if (err == KErrNone)
		{
		iWorkerThread.Resume();
		}
	else
		{
		iMessage->Complete(err);
		}
	}


//
// CWin32Resolver worker thread methods.
//

TInt CWin32Resolver::WorkerThreadStart(TAny* aPtr)
	{
	CWin32Resolver* self = reinterpret_cast<CWin32Resolver*>(aPtr);

	switch (self->iMessage->OppCode())
		{
		case EGetByName:
			{
			self->GetByName();
			break;
			}
		case EGetByAddress:
			{
			self->GetByAddress();
			break;
			}
		case ECancel:
		default:
			{
			__ASSERT_DEBUG(EFalse, Panic(EWinSockPrtResolverInvalidWorkerThreadRequest));
			}
		}

	return KErrNone;
	}

void CWin32Resolver::GetByName()
	{
	TNameRecord& nameRecord = (TNameRecord&)*iMessage->WriteBuffer().Ptr();
	struct hostent* hp;
	HBufC8* narrowHostNameBuf = HBufC8::New(nameRecord.iName.MaxLength() + 1); // Note, this is one bigger than the size of THostName to allow for a null termination character.
	if (narrowHostNameBuf == NULL)
		{
		iError = KErrNoMemory;
		}
	else
		{
		TPtr8 narrowHostNamePtr(narrowHostNameBuf->Des());
		CnvUtfConverter::ConvertFromUnicodeToUtf8(narrowHostNamePtr, nameRecord.iName);
		hp = gethostbyname(reinterpret_cast<const char*>(narrowHostNamePtr.PtrZ()));
		delete narrowHostNameBuf;
		if (hp)
			{
			TInetAddr& addr = reinterpret_cast<TInetAddr&>(nameRecord.iAddr);
			__ASSERT_DEBUG(hp->h_addrtype == AF_INET, Panic(EWinSockPrtResolverInvalidFamily));
			addr.SetFamily(KAfInet);
			__ASSERT_DEBUG(hp->h_length == 4, Panic(EWinSockPrtResolverInvalidAddressLength));
			TUint32* address = (TUint32*)hp->h_addr_list[0];
			addr.SetAddress(htonl(*address));
			iError = KErrNone;
			}
		else
			{
			iError = KErrNotFound;
			}
		}
	
	if (!SetEvent(iEvent))
		{
		__ASSERT_DEBUG(EFalse, Panic(EWinSockPrtResolverUnexpectedSetEventError));
		}
	}

void CWin32Resolver::GetByAddress()
	{
	TNameRecord& nameRecord = (TNameRecord&)*iMessage->WriteBuffer().Ptr();
	TInetAddr& addr = reinterpret_cast<TInetAddr&>(nameRecord.iAddr);
	struct hostent* hp;
	char addressBuf[4];
	*((TUint32*)addressBuf) = htonl(addr.Address());
	hp = gethostbyaddr(addressBuf, 4, AF_INET);
	if (hp)
		{
		TPtrC8 narrowAddressPtr((TUint8*)hp->h_name, User::StringLength((TUint8*)hp->h_name));
		CnvUtfConverter::ConvertToUnicodeFromUtf8(nameRecord.iName, narrowAddressPtr);
		iError = KErrNone;
		}
	else
		{
		iError = KErrNotFound;
		}
	
	if (!SetEvent(iEvent))
		{
		__ASSERT_DEBUG(EFalse, Panic(EWinSockPrtResolverUnexpectedSetEventError));
		}
	}


//
// CWin32ResolverWrapper.
//

CWin32ResolverWrapper* CWin32ResolverWrapper::NewL(MWin32ResolverObserver& aObserver, RWin32Factory& aWin32Factory)
	{
	CWin32ResolverWrapper* self = new(ELeave) CWin32ResolverWrapper(aObserver);
	CleanupStack::PushL(self);
	self->ConstructL(aWin32Factory);
	CleanupStack::Pop(self);
	return self;
	}

CWin32ResolverWrapper::~CWin32ResolverWrapper()
	{
	Cancel();
	iWin32Resolver.Close();
	}

CWin32ResolverWrapper::CWin32ResolverWrapper(MWin32ResolverObserver& aObserver)
	: CActive(CActive::EPriorityStandard), iObserver(aObserver)
	{
	}

void CWin32ResolverWrapper::ConstructL(RWin32Factory& aWin32Factory)
	{
	User::LeaveIfError(iWin32Resolver.Open(aWin32Factory));
	CActiveScheduler::Add(this);
	}

TInt CWin32ResolverWrapper::GetByName(TNameRecord& aName)
	{
	__ASSERT_DEBUG(!IsActive(), Panic(EWinSockPrtResolverWrapperGetByNameWhilstActive));
	TInt err = iWin32Resolver.GetByName(aName, iStatus);
	if (err == KErrNone)
		{
		SetActive();
		}
	return err;
	}

TInt CWin32ResolverWrapper::GetByAddress(TNameRecord& aName)
	{
	__ASSERT_DEBUG(!IsActive(), Panic(EWinSockPrtResolverWrapperGetByAddressWhilstActive));
	TInt err = iWin32Resolver.GetByAddress(aName, iStatus);
	if (err == KErrNone)
		{
		SetActive();
		}
	return err;
	}

void CWin32ResolverWrapper::DoCancel()
	{
	iWin32Resolver.Cancel();
	}

void CWin32ResolverWrapper::RunL()
	{
	iObserver.HandleWin32ResolverCompletion(iStatus.Int());
	}

TInt CWin32ResolverWrapper::RunError(TInt /*aError*/)
	{
	__ASSERT_DEBUG(EFalse, Panic(EWinSockPrtResolverWrapperUnexpectedRunError));
	return 0;
	}


//
// CWinSockResolver.
//

CWinSockResolver* CWinSockResolver::NewL(RWin32Factory& aFactory)
	{
	CWinSockResolver* self = new(ELeave) CWinSockResolver();
	CleanupStack::PushL(self);
	self->ConstructL(aFactory);
	CleanupStack::Pop(self);
	return self;
	}

CWinSockResolver::~CWinSockResolver()
	{
	delete iResolverWrapper;
	}

void CWinSockResolver::CancelCurrentOperation()
	{
	iResolverWrapper->Cancel();
	}

void CWinSockResolver::GetByName(TNameRecord& aName)
	{
	iResolverWrapper->GetByName(aName);
	}

void CWinSockResolver::GetByAddress(TNameRecord& aName)
	{
	iResolverWrapper->GetByAddress(aName);
	}

void CWinSockResolver::SetHostName(TDes& /*aNameBuf*/)
	{
	// TODO:
	ASSERT(EFalse);
	}

void CWinSockResolver::GetHostName(TDes& /*aNameBuf*/)
	{
	// TODO:
	ASSERT(EFalse);
	}

void CWinSockResolver::HandleWin32ResolverCompletion(TInt aError)
	{
	iNotify->QueryComplete(aError);
	}

CWinSockResolver::CWinSockResolver()
	{
	}

void CWinSockResolver::ConstructL(RWin32Factory& aFactory)
	{
	iResolverWrapper = CWin32ResolverWrapper::NewL(*this, aFactory);
	}