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

// wins\specific\ethernet.cpp

// PDD for the Ethernet under the windows emulator

// 

//

/**

 @file wins/specific/ethernet.cpp

*/

#include <ethernet.h>

#include "nk_priv.h"

#include "nk_plat.h"

#include <property.h>

#include "pcap.h"

/** @addtogroup enet Ethernet Drivers

 *  Kernel Ethernet Support

 */

/** @addtogroup enet_pdd Driver PDD's

 * @ingroup enet

 */

/** @addtogroup enet_byplatform Ethernet support by platform

 * @ingroup enet

 */

/** @addtogroup enet_wins WINS (Emulator) Ethernet support

 * @ingroup enet_byplatform

 */

// strings potentially written to ethernet.ini by netcards.exe

#define	KEpocIniEthSpeed10Mbps	"10Mbps"

#define	KEpocIniEthSpeed100Mbps	"100Mbps"

// entries in epoc.ini file:

#define	KEpocIniEthSpeedEntry	"ETHER_SPEED"

#define	KEpocIniEthNIFEntry	"ETHER_NIF"

#define	KEpocIniEthMACEntry	"ETHER_MAC"

#define KEthDrvPanicCategory "D32ETHER"

#define KLocalDriverNameMax				256

#define PCAP_FILTER "ether dst %x:%x:%x:%x:%x:%x or ether multicast and ether src not %x:%x:%x:%x:%x:%x"

_LIT(KPddName, "Ethernet.Wins");

// needs ldd version..

const TInt KMinimumLddMajorVersion=1;

const TInt KMinimumLddMinorVersion=0;

const TInt KMinimumLddBuild=122;

/** @addtogroup enet_windows Windows Emulator Ethernet Pdd

 * @ingroup enet_pdd

 * @ingroup enet_wins

 * @{

 */

/**

 * The Windows specific Ethernet physical device (factory) class 

 * @internalTechnology belongs to PDD which sits internally in kernel 

 */

class DDriverEthernet : public DPhysicalDevice

    {

public:

    /**

     * The constructor

     * Sets the drivers version number. Limits possible

	 * number of units to one only (unit 0)

     */

    DDriverEthernet();

    /**

     * Inherited from DPhysicalDevice.

	 * Install the driver by setting it's name

	 * @return KErrNone on success, other error code on failure

     */

    virtual TInt Install();

    /**

     * Inherited from DPhysicalDevice.

	 * Get the Capabilites of the driver

     * NOT supported but required as implementation of

	 * pure virtual in base class

     */

    virtual void GetCaps(TDes8 &aDes) const;

    /**

     * Inherited from DPhysicalDevice.

	 * Create a channel to a device

	 * @param aChannel a reference to a newly created channel object

	 * @param aUnit a unit for which the channel is being created

	 * @param anInfo pointer to a descriptor with additional info (may be NULL)

	 * @param aVer a requested version

     * @return KErrNone on success, other error code on failure

     */

    virtual TInt Create(DBase*& aChannel, TInt aUnit, 

						const TDesC8* anInfo, const TVersion &aVer);

    /**

     * Inherited from DPhysicalDevice.

	 * Validate that the info supplied would create a valid channel

	 * @param aUnit a unit for which validation is to be done

	 * @param anInfo pointer to a descriptor with additional info (may be NULL)

	 * @param aVer a version to be validated

     * @return KErrNone if valid, KErrNotSupported otherwise

	 */

    virtual TInt Validate(TInt aUnit, const TDesC8* anInfo, const TVersion &aVer);

	};

/**

 * The WINS specific Ethernet channel class for the libpcap library

 * @internalTechnology belongs to PDD which sits internally in kernel 

 */

class DEthernetWins : public DEthernet

    {

	/**

     * The Worker Thread

     * @param aDEthernetWins Pointer to this object

     * @return Should never return

     */

    friend TInt WorkThread(DEthernetWins * aDEthernetWins);

public:

	enum TWinsEtherPanic

	{

	EBadMacAddress = 1, // means bad MAC address in ini file or entry for it missing or ini file missing

	ENoNetInterface, // means entry for network interface name missing in ini file or ini file missing

	EPcapNull	// means Wpcap couldn't be initialised - potentially not installed or name of network interface in ini file wrong

	};

    /**

     * The Constructor.

     */

    DEthernetWins();

    /**

     * The Destructor.

     */

    ~DEthernetWins();

	/**

     * The Isr plays a role of the pcap callback.

     * Do NOT call the function directly

     * @param thisObject a pointer to this object

     * @param header the received packet's pcap header

     * @param pkt_data the received packet

	 * @post new packet is copied to LDD's RX buffers' queue

	 */

    static void Isr(u_char *thisObject,   

                     const struct pcap_pkthdr *header, 

                     const u_char *pkt_data);

    /**

     * The DoCreate Method.

     * Sets up the channel as part of the object creation

     * and retrieves the MAC address from epoc.ini file.

	 * Also creates wpcap handler and thread for wpcap loop.

	 * @pre epoc32\\data\\epoc.ini must exist with entries: "ETHER-NIF=..", "ETHER-MAC=..", "ETHER-SPEED=.."

	 * @param aUnit a unit for which the channel is being created

	 * @panic D32ETHER reason: (1) can't get proper MAC address (2) can't get

	 * network interface name (3) can't initialise wpcap

	 * @return KErrNone on success, other error code on failure

	 */

    TInt DoCreate(TInt aUnit); 

    /**

     * DEthernet implementation.

	 * Start the receiver.

     * Resumes pcap thread. Sets status to ready.

	 * @return KErrNone on success or suitable error code on failure

     */

    virtual TInt Start();

    /**

     * DEthernet implementation.

	 * Stop the receiver.

     * @param aMode possible values are: EStopNormal (=0), EStopEmergency (=1)

	 * @post pcap thread suspended, status set to not ready

     */

    virtual void Stop(TStopMode aMode);

    /**

     * DEthernet implementation.

	 * Validates a new configuration - should be called before Configure()

     * @param aConfig is the configuration to be validated

     * @return KErrNone if aConfig valid, KErrNotSupported otherwise

     * @see Configure()

     */

    virtual TInt ValidateConfig(const TEthernetConfigV01 &aConfig) const;

    /**

     * DEthernet implementation.

	 * Configure the PDD and pcap library

     * Reconfigure the library using the new configuration supplied.

	 * Sets pcap filter to read only frames with destination address set to

	 * broadcast, multicast or MAC addresss from defaultConfig.

     * This will not change the MAC address.

     * @param aConfig The new configuration

	 * @return KErrNone on success, suitable error code otherwise

     * @see ValidateConfig()

     * @see MacConfigure()

     */

    virtual TInt Configure(TEthernetConfigV01 &aConfig);

    /**

     * DEthernet implementation.

	 * Change the MAC address - writes new MAC address in defaultConfig.

	 * If new settings are to have any effect then pcap filter

	 * ought to be set again which is done by 'Configure()'

	 * @param aConfig a configuration structure containing the new MAC

     * @see Configure()

     */

    virtual void MacConfigure(TEthernetConfigV01 &aConfig);

	/**

     * DEthernet implementation.

	 * Get the current config from defaultConfig member varaiable

	 * which is assumed to be up to date.

     * Fills in the following fields:

     * The Transmit Speed

     * The Duplex Setting

     * The MAC address

     * @param aConfig is a TEthernetConfigV01 reference that will be filled in

     */

    virtual void GetConfig(TEthernetConfigV01 &aConfig) const;

	/**

     * DEthernet implementation.

	 * Dummy method, required as pure virtual in base class

     */

    virtual void CheckConfig(TEthernetConfigV01 &aConfig);

	/**

     * DEthernet implementation.

	 * Should query the capabilites.

     * NOT supported but required as pure virtual in base class

     */

    virtual void Caps(TDes8 &aCaps) const;

    /**

     * DEthernet implementation.

	 * Transmit data via wpcap

     * @param aBuffer reference to the data to be sent

     * @return KErrNone on success, other error code on failure

     */

    virtual TInt Send(TBuf8<KMaxEthernetPacket+32> &aBuffer);

    /**

     * DEthernet implementation.

	 * Retrieve data

     * Pull the received data out of the pcap library and into the supplied buffer. 

     * Need to be told if the buffer is OK 

     * @param aBuffer Reference to the buffer to be used to store the data in

     * @param okToUse Bool to indicate if the buffer is usable

     * @return KErrNone on success, other error code on failure

     */

    virtual TInt ReceiveFrame(TBuf8<KMaxEthernetPacket+32> &aBuffer, TBool okToUse);

	/**

     * DEthernet implementation.

	 * Disables all IRQ's 

     * @return The IRQ level before it was changed

     * @see RestoreIrqs()

     */

    virtual TInt DisableIrqs();

    /**

     * DEthernet implementation.

	 * Restore the IRQ's to the supplied level

	 * @param aIrq The level to set the irqs to.

     * @see DisableIrqs()

     */

    virtual void RestoreIrqs(TInt aIrq);

	/**

     * DEthernet implementation.

	 * Return the DFC Queue that this device should use

     * @param aUnit a channel's unit number (ignored - only one unit possible)

     * @return a DFC Queue to use

     */

    virtual TDfcQue* DfcQ(TInt aUnit);

private:

 	static TBool DEthernetWins::IsTcp(TDesC8 &aFrame);

 	static TInt DEthernetWins::GetTcpAckNumber(TDesC8 &frame);

 	static TInt DEthernetWins::GetTcpSeqNumber(TDesC8 &frame);

	/**

     * Read network interface to be used from configuration file. Panic if

	 * pre-conditions are not satisfied.

	 * @pre epoc32\\data\\epoc.ini must exist with entry: "ETHER-NIF=existing_nif_name"

	 * @post network interface name put in a member variable: iNetInterfaceName

	 * @panic D32ETHER reason: (2) can't get network interface name 

     */

	void  SetDriverName();

	/**

	 * Read MAC address from a configuration file and put it

	 * into defaultConfig member variable checking before if the

	 * one from the file is correct. Panic if pre-conditions are not satisfied

	 * (although in case when MAC address is improper).

	 * @pre epoc32\\data\\epoc.ini must exist with entry: "ETHER-MAC=proper_mac_address"

	 * @panic D32ETHER reason:  EBadMacAddress

	 * @return KErrNone on success (panics on failure)

	 */

	TInt SetMacAddress();

private:

    /**

     * The handle to the pcap interface - wpcap specific

     */

    pcap_t * iPcapPtr;

    /**

     * Saved received packet information - wpcap specific:

	 * pointer to a structure that holds general information about the packet:

	 * the time in which it was sniffed, the length of this packet, 

	 * and the length of his specific portion (in case it is fragmented)

     */

    const struct pcap_pkthdr * iPcapHeader; 

    /**

     * Saved receive packet data - wpcap specific

     */

    const u_char * iPcapPktData;

    /**

     * Id of the receiver - wpcap thread

     */

    unsigned long iWorkerThreadId;

	/**

     * Contains the handle to wpcap thread. 

     */

	HANDLE				iThreadHandle;

    /**

     * Stores the unit number (only one interface possible in 

	 * this implementation, so it will have value "0")

     */

    TInt  iUnit;

    /**

     * Is ETrue if the chip has been fully configured and is ready

	 * for receiving frames. Is set to ETrue in Start(), to EFalse

	 * in Stop(). Initialized in constructor as EFalse.

     */

    TBool iReady;

    /**

     * Contains the default/current configuration of the driver.

	 * Updated whenever configuration is to be changed.

     */

    TEthernetConfigV01 defaultConfig;

	/**

     * Contains the network interface name to be used 

	 * @see SetDriverName()

     */

	char	iNetInterfaceName[KLocalDriverNameMax];

    };

/** @} */ // End of wins ethernet pdd

DDriverEthernet::DDriverEthernet()

// Constructor

    {

    __KTRACE_OPT(KHARDWARE, Kern::Printf("DDriverEthernet::DDriverEthernet()"));

    iUnitsMask=0x1;	// support unit 0 only

    iVersion=TVersion(KEthernetMajorVersionNumber,

                      KEthernetMinorVersionNumber,

                      KEthernetBuildVersionNumber);

	}

TInt DDriverEthernet::Install()

// Install the driver

    {

    __KTRACE_OPT(KHARDWARE, Kern::Printf("DDriverEthernet::Install()"));

    return SetName(&KPddName);

    }

void GetWinsEthernetsCaps(TDes8 &aCaps, TInt aUnit=0)

    {

    __KTRACE_OPT(KHARDWARE, Kern::Printf("GetWinsEthernetsCaps(TDes8 &aCaps, TInt aUnit)"));

    TEthernetCaps capsBuf;

	aUnit=0;

    aCaps.FillZ(aCaps.MaxLength());

    aCaps=capsBuf.Left(Min(capsBuf.Length(),aCaps.MaxLength()));

    }

void PanicFromWinsEtherDrv(TInt aReason)

	{

	Kern::Fault(KEthDrvPanicCategory, aReason);

	}

void DDriverEthernet::GetCaps(TDes8 &aDes) const

// Return the driver's capabilities

    {

    __KTRACE_OPT(KHARDWARE, Kern::Printf("DDriverEthernet::GetCaps(TDes8 &aDes) const"));

    GetWinsEthernetsCaps(aDes);	

    }

TInt DDriverEthernet::Create(DBase*& aChannel, 

                             TInt aUnit, 

                             const TDesC8* aInfo, 

                             const TVersion& aVer)

// Create a driver

    {

    __KTRACE_OPT(KHARDWARE, 

		Kern::Printf("DDriverEthernet::Create(DBase*& aChannel, TInt aUnit, const TDesC8* nInfo, const TVersion& aVer)"));

    TInt ret;

	ret = Validate( aUnit, aInfo, aVer);

	if ( KErrNone != ret )

		return ret;

	ret = KErrNoMemory;

	DEthernetWins* ptrPdd = new DEthernetWins;

	if ( ptrPdd )

        {

        ret = ptrPdd->DoCreate(aUnit);

        if ( ret != KErrNone)

			{

            delete ptrPdd;

			}	

		else

			aChannel = ptrPdd;

        }

    return ret;

    }

TInt DDriverEthernet::Validate(TInt aUnit, 

                               const TDesC8* /*aInfo*/, 

                               const TVersion& aVer)

//	Validate the requested configuration

    {

    __KTRACE_OPT(KHARDWARE, Kern::Printf("DDriverEthernet::Validate(TInt aUnit, const TDesC8* /*aInfo*/, const TVersion& aVer)"));

    if ((!Kern::QueryVersionSupported(iVersion,aVer)) || 

        (!Kern::QueryVersionSupported(aVer,TVersion(KMinimumLddMajorVersion,

                                                    KMinimumLddMinorVersion,

                                                    KMinimumLddBuild))))

		{

        return KErrNotSupported;

		}

	if (aUnit != 0)

		{

        return KErrNotSupported;

		}

	return KErrNone;

    }

DEthernetWins::DEthernetWins()

// Constructor

	{

    __KTRACE_OPT(KHARDWARE, Kern::Printf("DEthernetWins::DEthernetWins()"));

    iReady = EFalse;

	// set default configuration - must be set before DoCreate gets called

	defaultConfig.iEthSpeed  = KEthSpeedUnknown;

    defaultConfig.iEthDuplex = KEthDuplexUnknown;

	// MAC address initially set to NULL

	defaultConfig.iEthAddress[0] = 0; 

    defaultConfig.iEthAddress[1] = 0; 

    defaultConfig.iEthAddress[2] = 0; 

	defaultConfig.iEthAddress[3] = 0; 

    defaultConfig.iEthAddress[4] = 0; 

    defaultConfig.iEthAddress[5] = 0; 

	iNetInterfaceName[0] = '\0';

	// wpcap

	iPcapPtr = NULL;

	}

DEthernetWins::~DEthernetWins()

// Destructor

	{

    __KTRACE_OPT(KHARDWARE, Kern::Printf("DEthernetWins::~DEthernetWins()"));

	if (iPcapPtr)

		{

		pcap_close(iPcapPtr);