nettimer.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
/* Definitions for various IP definitions and structures. */
#ifndef _NB_NETTIMER_H
#define _NB_NETTIMER_H
#include <buffers.h>
#include <utils.h>
//#define  NETTIMER_DIAG (1)
 
class TimeOutManager;
 
class TimeOutElement
{
   private:
    TimeOutElement *volatile pNext;
 
    TimeOutElement *volatile pPrev;
 
protected:
    TimeOutManager *volatile pOwner;
 
    volatile uint32_t NextTime;
    uint32_t Interval;
 
#ifdef NETTIMER_DIAG
    uint32_t seq_check;
    uint32_t sentinel;
#endif
 
   public:
    virtual void TimeElementEvent() = 0;
    TimeOutElement();    // Constructor
    ~TimeOutElement();   // Destructor
    inline uint32_t GetNextTime() { return NextTime; };
    inline void ChangeNextInterval(uint32_t nt) { Interval = nt; };
    inline uint32_t GetInterval() { return Interval; }
    void SetNextTime(uint32_t nextTime);
    friend class TimeOutManager;
} __attribute__((packed));
 
class TimeOutManager
{
    OS_CRIT ManagerCrit;
    TimeOutElement *volatile pElHead;
    TimeOutElement *volatile pElTail;
    volatile uint32_t NextTime;
    volatile uint32_t LastRun;
    OS_TCB * OwningTaskTcb;
 
    void Remove(TimeOutElement &te);
    void Insert(TimeOutElement &te);
    void CheckTime(TimeOutElement &te);
 
#ifdef NETTIMER_DIAG
    void CheckList(const char *msg, TimeOutElement *pte);
    void DumpList(uint32_t n);
    volatile uint32_t entries;
#endif
   public:
    TimeOutManager();   // Constructor
 
    void InitTaskOwner();
 
#ifdef NETTIMER_DIAG
    void Report();
#endif
 
    // Cause a repetitive event to happen every TickInterval ticks...
    // OK to spread allows the system to spread out things like 1 sec ticks uniformly among tick intervals.
    void RegisterInterval(TimeOutElement &te, uint16_t TickInterval, const char *fromwhere, bool OkToSpread = false);
 
    // Cause an event to trigger at a specific time.
    void RegisterTriggerAt(TimeOutElement &te, uint32_t TriggerTime);
 
    void RegisterTriggerAt(TimeOutElement &te, TickTimeout & tt);
 
 
    // Remove either a At or interval event from the time manager...
    void DeRegister(TimeOutElement &te);
 
    // Returns the time ticks till the next event...
    // Ok to call this function when no events are due...
 
    uint32_t ProcessEvents();
 
    void CoreProcessEvents();
};
 
inline void TimeOutElement::SetNextTime(uint32_t nextTime)
{
    if (pOwner) pOwner->RegisterTriggerAt(*this, nextTime);
}
 
 
 
typedef void(ActionFunction)();
 
extern TimeOutManager NetTimeOutManager;
 
class IntervalAction : public TimeOutElement
{
   private:
    ActionFunction *m_pFunc;
 
   public:
    IntervalAction(ActionFunction *pf);
    virtual void TimeElementEvent();
};
 
typedef void(DHCPProcessFunction)(PoolPtr p);
extern DHCPProcessFunction *pDHCPProcessFunction;
 
typedef void(MULTICastProcessFunction)(PoolPtr p, uint16_t csum);
extern MULTICastProcessFunction *pMultiCastFunc;
 
#ifdef IPV6
#include <udp.h>
typedef void(DHCPv6ProcessFunction)(UDPPacket *pkt);
extern DHCPv6ProcessFunction *pDHCPv6ClientProcessFunction;
#endif
#endif