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

/**
 @file 
 @internalComponent
 */

#ifndef __TUN_H__
#define __TUN_H__

#include <posthook.h>
#include <nifif.h>
#include "tunfamily.h"
#include "tun.pan"

const TUint KProtocolTUN    = 145; // number that is unassigned by IANA
const TUint KTunTos         = 192; // 0xC0; uses the UNUSED 7,8 MSB of Differentiated Services  

class CProtocolTun;
class CTunFlowInfo;
class CNifIfBase;

class CSapTun : public CServProviderBase
/** 
 *  Class Derived from CServProviderBase. 
 *  Inherit virtual functions from CServProviderBase.This Class is socket support for this 
 *  Hook (protocol).Protocol or Hook could be manipulated by the Socket using socket options.
 *  This class will be used to take downlink information from the private client.The SAP will 
 *  called for all the Socket opened by the socket. SAP is 1 to 1 with Socket.
 *  we are maintaining a singleton pattern for this SAP
 **/
    {

public:
    friend class CProtocolTun;

protected:
    CSapTun();
    ~CSapTun();
    
public:
    //static CSapTun* GetInstanceL();
    void Ioctl(TUint /*level*/,TUint /* name*/,TDes8* /* anOption*/);
    void Start();
    void Shutdown(TCloseType option);
    void LocalName(TSockAddr& anAddr) const; 
    TInt SetLocalName(TSockAddr& anAddr); 
    void RemName(TSockAddr& anAddr) const;
    TInt SetRemName(TSockAddr& anAddr);
    TInt GetOption(TUint /*level*/,TUint /*name*/,TDes8& /*anOption*/)const;    
    void CancelIoctl(TUint /*aLevel*/,TUint /*aName*/);
    TInt SetOption(TUint aLevel,TUint aName,const TDesC8& anOption); 
    void ActiveOpen();
    void ActiveOpen(const TDesC8& /*aConnectionData*/);
    TInt PassiveOpen(TUint /*aQueSize*/);
    TInt PassiveOpen(TUint /*aQueSize*/,const TDesC8& /*aConnectionData*/);
    void Shutdown(TCloseType /*option*/,const TDesC8& /*aDisconnectionData*/);
    void AutoBind();
    TInt SecurityCheck(MProvdSecurityChecker* aChecker);

private:
    //static CSapTun* iInstance;
    CProtocolTun* iProtocol;
    CTunFlowInfo* iFlowInfo;
    };  //End Class CProtocolSap

//CSapTun* CSapTun::iInstance = NULL;

class CProtocolTun : public CProtocolPosthook
    {
    friend class CSapTun;
public:  // Constructors and destructor

    /**
     * Constructor.
     */

    CProtocolTun ();

    /* 
     * Two Phase Construction
     */
    static CProtocolTun* NewL();

    /**
     * Destructor.
     */
    virtual ~CProtocolTun ();

public: // Functions from base classes

    /**
     * From CProtocolBase  
     * Used as second phase of Two Phase construction
     * @param aTag Name
     * @return void
     */
    void ConstructL ();

    /**
     * From CProtocolBase  
     * @since 
     * @param aDesc Descriptor to be filled by this method.
     * @return void
     */
    virtual void Identify (TServerProtocolDesc * aDesc) const;

    /**
     * Static method that can be invoked from the Protocol Family 
     * @since 
     * @param aDesc Descriptor to be filled by this method.
     * @return void
     */
    static void Identify (TServerProtocolDesc & aDesc);

    /**
     * From CProtocolPostHook Handles attach to the stack
     * @since
     * @return void
     */
    void NetworkAttachedL();

    /**
     * From CProtocolPostHook Handles detach from the stack
     * @since
     * @return void
     */
    void NetworkDetached();

    /**
     * From MIp6Hook Handles received packets. 
     * @since 
     * @param aPacket Packet received.
     * @param aInfo Info structure.
     * @return void
     */       
    virtual TInt ApplyL (RMBufHookPacket & /* aPacket */ ,RMBufRecvInfo & /* aInfo */ );

    /**
     * From MIp6Hook Handles outbound opening. 
     * @since 
     * @param aHead Flow-specific precomputed data.
     * @param aFlow Flow.
     * @return void
     */       
    virtual MFlowHook *OpenL (TPacketHead & aHead, CFlowContext * aFlow);

    /**
     * NewSAPL function to create a CSapTun instance
     * and use for setting up the LocalAddress Information
     * @param aProtocol ignored in our case.
     * @return instance of the CServProviderBase instance CSapFullTunnel
     */
    CServProviderBase* NewSAPL(TUint aProtocol);

    /**
     *  Cancels the Sap creation
     *  @param the Sap instance that has to be removed 
     */ 
  //  void CancelSap(CSapTun *aSap);

    /**
     *  Sets the NifBase instances to be used for Control functionality
     *  @param the NifBase instance that will be retained.
     */
    void SetCNifBase(CNifIfBase* aNifBase)
        {
        iNifBase = aNifBase;
        }
    
    void SetAppPortNum(TUint aPort)
        {
        iAppPortNum = aPort;
        iPortSet = ETrue;
        }
    
    TBool IsPortSet()
        {
        return iPortSet;
        }


private:
    TUint iAppPortNum;  // Tunnel port configured.
    TBool iPortSet;     //Bool to check whether the port is set/not.
    RPointerArray<CSapTun> iSapList;  // List of SAP instances created.
    CNifIfBase* iNifBase;    // CNifBase* instance
    CTunFlowInfo* iFlowinfo;   // instance of the Flow Hook
    CSapTun* iSapInstance; // instance of sap

    };

/**
 *  TUN Driver flow hook
 *  Outbound Flow hook and performs actions on the packets
 *  destined for the Virtual Tunnel Nif.
 */
class CTunFlowInfo : public CBase, public MFlowHook
    {
    friend class CProtocolTun;
    friend class CSapTun;

public: // Constructors & destructors

    /**
     * Constructor.
     */

    CTunFlowInfo();

    /**
     * Copy Constructor.
     */

    CTunFlowInfo(CTunFlowInfo* aInstance )
    :iAppPortNum(aInstance -> iAppPortNum)
        {}

    /**
     * Destructor.
     */

    ~CTunFlowInfo();


public: // Functions from base classes

    /**
     * From MFlowHook Open and Close implements reference counting system.
     * @since
     * @param
     * @return void
     */
    void Open ();

    /**
     * From MFlowHook Informs stack if the hook is ready. Can update address
     * information.
     * @since
     * @param aHead Address information of the flow.
     * @return TInt 0 => ready, >0 => pending, <0 => error.
     */
    TInt ReadyL (TPacketHead & aHead);

    /**
     * Called by IP when processing outbound packet.
     * @since
     * @param aPacket Complete packet
     * @param aInfo Information block associated with the packet
     * @return TInt 0 => processed, <0 => discarded, >0 => restart processing
     */
    TInt ApplyL (RMBufSendPacket & aPacket, RMBufSendInfo & aInfo);

    /**
     * From MFlowHook Open and Close implements reference counting system.
     * @since
     * @param
     * @return void
     */
    void Close ();
    
    void SetAppPortNum(TUint aPort)
        {
        iAppPortNum = aPort;
        }
    
private:    // Data

    TInt iRef; // Reference count
    TUint iAppPortNum; // Tunnel port configured.

    };


#endif //__TUN_H__