/*

* Copyright (c) 2005-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 "wintap.h"

#include <assert.h>

#include <stdio.h>

#ifdef EKA2

#include <platform/emulator.h>

#endif

/**

 *

 *	The start of most EtherTap specific routines

 *

 **/

static TIsr GlobIsr = NULL;

static void * GlobObj = NULL;

static int MatchTunAdapter(const char* aDevName)

	{

	const char match[] = "TAP";

	const char matchl[] = "tap";

	// Check the first 3 charecters

	if (aDevName[0] == match[0]

		&& aDevName[1] == match[1]

		&& aDevName[2] == match[2])

		return 1;

	else if (aDevName[0] == matchl[0]

		&& aDevName[1] == matchl[1]

		&& aDevName[2] == matchl[2])

		return 1;

	else

		return 0;

	}

static int GetIfName(IP_ADAPTER_INFO& iAdapterinfo)

	{

	DWORD			numInterfaces;

    HMODULE hModule = LoadLibraryA("iphlpapi.dll");

    if(!hModule)

        return -1;

    DWORD (WINAPI * pfGetNumberOfInterfaces)(PDWORD) = (DWORD (WINAPI * )(PDWORD))GetProcAddress(hModule, "GetNumberOfInterfaces");

    DWORD (WINAPI * pfGetAdaptersInfo)(PIP_ADAPTER_INFO,PULONG) = (DWORD (WINAPI *)(PIP_ADAPTER_INFO,PULONG))GetProcAddress(hModule, "GetAdaptersInfo");

	// weiredness alert - windows returns found adapters+1

	if (pfGetNumberOfInterfaces(&numInterfaces) != ERROR_SUCCESS)

		return -1;

	ULONG            ulOutBufLen;

	ulOutBufLen = sizeof(IP_ADAPTER_INFO) * (numInterfaces);

	IP_ADAPTER_INFO  *pAdapterInfo = NULL;

	pAdapterInfo = new IP_ADAPTER_INFO[numInterfaces];

	if (pAdapterInfo && (pfGetAdaptersInfo( pAdapterInfo, &ulOutBufLen) != ERROR_SUCCESS)) 

		{

		delete pAdapterInfo;

		return -1;

		}

	IP_ADAPTER_INFO  *pCurAdapterInfo = pAdapterInfo;

	int count = 1, matchCount = 0;

	while (pCurAdapterInfo != NULL)

		{	

		// Optimize for when we already have the index

		if (iAdapterinfo.Index == pCurAdapterInfo->Index)

			{

			matchCount++;

			iAdapterinfo = *pCurAdapterInfo;

			break;

			}

		if (MatchTunAdapter(pCurAdapterInfo->Description))

			{

			matchCount++;

			iAdapterinfo = *pCurAdapterInfo;

			}

		pCurAdapterInfo = pCurAdapterInfo->Next;

		count++;

		}

	if (matchCount == 0)

		{

		delete[] pAdapterInfo;

		return -1;

		}

	else if (matchCount > 1)

		{}

	iAdapterinfo.Next = NULL;

	delete[] pAdapterInfo;

	return 0;

	}

static int WorkThread(HANDLE * iWinTapHandle);

int InitDriver(HANDLE& iWinTapHandle, HANDLE& iThreadHandle, PACKET& iWritePacket, IP_ADAPTER_INFO& iAdapterinfo)

// Sets up the PDD

	{

	int ret = 0;

	if ((ret = GetIfName(iAdapterinfo)) != 0)

		return ret;	

	// Fromat the GUID to get the file name

	char szFileName[256];	

	sprintf(szFileName, ("%s%s%s"), ("\\\\.\\"), iAdapterinfo.AdapterName, (".tap"));

	iWinTapHandle = CreateFileA(szFileName,

								GENERIC_READ | GENERIC_WRITE,

								FILE_SHARE_READ | FILE_SHARE_WRITE,

								NULL,

								OPEN_EXISTING,

								FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED,

								NULL);

	if (iWinTapHandle == INVALID_HANDLE_VALUE)

		{

		//OUTPUT_ERROR("could not open file handle\n");

		CloseHandle(iWinTapHandle);

		ret = -1;

		return ret;

		}

	// set the device to connected

	ULONG status = 1;

	DWORD len;

	if (!DeviceIoControl(iWinTapHandle,

		TAP_IOCTL_SET_MEDIA_STATUS ,&status, sizeof(status), &status, sizeof(status), &len, NULL))

		{

		// FUDGE alert

		if (!DeviceIoControl(iWinTapHandle,

			TAP_IOCTL_SET_MEDIA_STATUS_V8 ,&status, sizeof(status), &status, sizeof(status), &len, NULL))

			{

			//OUTPUT_ERROR("Could not set media status to open\n");

			return ret;

			}

		}

	// Call GetDriverName again, this time to reset the correct info for the connected Device

	if((ret = GetIfName(iAdapterinfo)) != 0)

		return ret;

	iWritePacket.OverLapped.hEvent 		= CreateEvent(NULL, TRUE, FALSE, NULL);

	u_long WorkerThreadId;

	if ((iThreadHandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)WorkThread, &iWinTapHandle,

		CREATE_SUSPENDED,&WorkerThreadId)) != NULL)

		{

		ret = 0;

		}

	else

		{

		//OUTPUT_ERROR("CreateThread() failed to create worker thread");

		}

	return ret;

	}

void DoClose(HANDLE& iWinTapHandle, HANDLE& iThreadHandle, PACKET& iWritePacket)

	{

	if (iWinTapHandle != INVALID_HANDLE_VALUE)

		{

		// Cancel reads, Writes 

		CancelIo(iWinTapHandle);

		// Close read and write events

		CloseHandle(iWritePacket.OverLapped.hEvent);

		// Close the read thread

		if (!TerminateThread(iThreadHandle, 0))

			{

			//__KTRACE_OPT(KHARDWARE, Kern::Printf("Could not Terminate thread\n"));

			}

		CloseHandle(iThreadHandle);

		DWORD status = 0, len;

		if (!DeviceIoControl(iWinTapHandle,

			TAP_IOCTL_SET_MEDIA_STATUS ,&status, sizeof(status), &status, sizeof(status), &len, NULL))

			{

			// Big fudge --

			if (!DeviceIoControl(iWinTapHandle,

				TAP_IOCTL_SET_MEDIA_STATUS_V8 ,&status, sizeof(status), &status, sizeof(status), &len, NULL))

				{

				//__KTRACE_OPT(KHARDWARE, Kern::Printf("Could not set media status to close\n"));

				}

			}

		CloseHandle(iWinTapHandle);

		iWinTapHandle = INVALID_HANDLE_VALUE;

		}

	}

void SetIsr(void * aObject, TIsr aIsr)

	{

	assert(aIsr != NULL);

	assert(aObject != NULL);

	GlobObj = aObject;

	GlobIsr = aIsr;

	}

static int WorkThread(HANDLE * iWinTapHandle)

	{

    //__KTRACE_OPT(KHARDWARE, Kern::Printf("WorkThread(DEthernetWins * aDEthernetWins)"));

	int err = 0;

	u_char			buffer[2000];

	PACKET			m_ReadPacket;

	m_ReadPacket.OverLapped.hEvent 		= CreateEvent(NULL, TRUE, FALSE, NULL);

	while( err == 0 )

		{		

		m_ReadPacket.OverLapped.Offset 		= 0;

		m_ReadPacket.OverLapped.OffsetHigh 	= 0;

		m_ReadPacket.OverLapped.Internal	= 0;

		m_ReadPacket.OverLapped.InternalHigh= 0;

		m_ReadPacket.Buffer					= buffer;

		m_ReadPacket.Length					= 0;

    	//__KTRACE_OPT(KHARDWARE, Kern::Printf("Starting to Read \n"));

	    if (*iWinTapHandle != INVALID_HANDLE_VALUE)

			{

			if (!ReadFile(*iWinTapHandle, m_ReadPacket.Buffer, 2000, 

				&(m_ReadPacket.Length), &m_ReadPacket.OverLapped))

				{

				if(GetLastError() != ERROR_IO_PENDING) 

					{

					//__KTRACE_OPT(KHARDWARE, Kern::Printf("m_ReadPacket() Failed "));

					err = -3;

					break;

					}

				DWORD Result = WaitForSingleObject(m_ReadPacket.OverLapped.hEvent, INFINITE);

				switch(Result)

					{

					// OVERLAPPED structure's event has been signaled. 

					case WAIT_OBJECT_0:

						if (GetOverlappedResult(*iWinTapHandle, &m_ReadPacket.OverLapped, 

							&m_ReadPacket.Length, FALSE) == 0)

							{

    						//__KTRACE_OPT(KHARDWARE, Kern::Printf("** Error in m_ReadPacket() **\n"));

							err = -3;

							}

						else

							{

							// m_ReadPacket operation completed successfully.

    						//__KTRACE_OPT(KHARDWARE, Kern::Printf("** Completed in m_ReadPacket() **\n"));

							err = 0;

							}

						break;

					default:

						 // An error has occurred in WaitForSingleObject.

						 // This usually indicates a problem with the

						// OVERLAPPED structure's event handle.

						err = -3;

						break;

					}

				}

			else

				{

				err = 0;

    			//__KTRACE_OPT(KHARDWARE, Kern::Printf("** Completed in m_ReadPacket() **\n"));

				}			

			}

		else

			{

    		//__KTRACE_OPT(KHARDWARE, Kern::Printf("ReadPacket() No adaptor open\n"));

			err = -1;

			}

		GlobIsr(GlobObj, err, buffer, &m_ReadPacket.Length);

		}

	CloseHandle(m_ReadPacket.OverLapped.hEvent);

	return -3;

	}

int DoSend(PACKET& iWritePacket, HANDLE& iWinTapHandle)

	{

    //__KTRACE_OPT(KHARDWARE, Kern::Printf("DEthernetWins::Send(TBuf8<KMaxEthernetPacket+32> &aBuffer)"));

    int err;

    if ( iWinTapHandle != INVALID_HANDLE_VALUE )

		{

		iWritePacket.OverLapped.Offset 		= 0;

		iWritePacket.OverLapped.OffsetHigh 	= 0;

		iWritePacket.OverLapped.Internal		= 0;

		iWritePacket.OverLapped.InternalHigh	= 0;

		if(!WriteFile(iWinTapHandle, iWritePacket.Buffer, iWritePacket.Length, NULL, &iWritePacket.OverLapped))

			{

			if(GetLastError() != ERROR_IO_PENDING) 

				{

				//__KTRACE_OPT(KHARDWARE, Kern::Printf("WriteFile() Failed  "));

				err = -23; //KErrWrite

				return err;

				}

			else	//Pending Write

				{

				DWORD written;

				DWORD Result = WaitForSingleObject(iWritePacket.OverLapped.hEvent, INFINITE);

				switch(Result)

					{

					// OVERLAPPED structure's event has been signaled. 

					case WAIT_OBJECT_0:

						if (!GetOverlappedResult(iWinTapHandle, &iWritePacket.OverLapped, &written, FALSE))

							{

			            	//__KTRACE_OPT(KHARDWARE, Kern::Printf("** Error in WritePacket() **\n"));

							err = -23; //KErrWrite

							}

						else

							{

							// Write operation completed successfully.

            				//__KTRACE_OPT(KHARDWARE, Kern::Printf("** Completed in WritePacket() **"));

							err = 0;

							}

						break;

					default:

						 // An error has occurred in WaitForSingleObject.

						 // This usually indicates a problem with the

						// OVERLAPPED structure's event handle.

						err = -23; //KErrWrite

						break;

					}

				}

			}

		else //Write went fine

			{

            //__KTRACE_OPT(KHARDWARE, Kern::Printf("** Completed in WritePacket() **\n"));

			err = 0;

			}

		}

    else

		{

        //__KTRACE_OPT(KHARDWARE, Kern::Printf("WritePacket() No adaptor open\n"));

		err = -12; //KErrPathNotFound

		}

    return err;

	}