spfifc.h

BCAST Implementation for NS2

    friend class InactTimer;
    friend class NbrHelloTimer;
    friend class HoldTimer;
    friend class DDRxmtTimer;
    friend class RqRxmtTimer;
    friend class ProgressTimer;
    friend class OSPF;
    friend class LSA;
    friend class SpfArea;
    friend class SpfNbr;
    friend class CryptK;
};

// Inline functions
inline SpfArea *SpfIfc::area() const
{
    return(if_area);
}
inline int SpfIfc::state() const
{
    return(if_state);
}
inline InAddr SpfIfc::net() const
{
    return(if_net);
}
inline InAddr SpfIfc::mask() const
{
    return(if_mask);
}
inline uns16 SpfIfc::mtu() const
{
    return(if_mtu);
}
inline byte SpfIfc::drpri() const
{
    return(if_drpri);
}
inline int SpfIfc::if_index() const
{
    return if_IfIndex;
}
inline uns16 SpfIfc::cost() const
{
    return(if_cost);
}
inline InAddr SpfIfc::dr() const
{
    return(if_dr);
}
inline InAddr SpfIfc::bdr() const
{
    return(if_bdr);
}
inline byte SpfIfc::rxmt_interval() const
{
    return(if_rxmt);
}
inline byte SpfIfc::xmt_delay() const
{
    return(if_xdelay);
}
inline uns16 SpfIfc::hello_int() const
{
    return(if_hint);
}	
inline uns32 SpfIfc::dead_int() const
{
    return(if_dint);
}
inline uns32 SpfIfc::poll_int() const
{
    return(if_pint);
}
inline autyp_t SpfIfc::autype() const
{
    return(if_autype);
}
inline const byte* SpfIfc::passwd() const
{
    return(if_passwd);
}
inline int SpfIfc::mcfwd() const
{
    return(if_mcfwd);
}
inline bool SpfIfc::demand() const
{
    return(if_demand);
}
inline bool SpfIfc::passive() const
{
    return(if_passive);
}
inline bool SpfIfc::igmp() const
{
    return(igmp_enabled);
}
inline  void SpfIfc::if_build_dack(LShdr *hdr)
{
    if_build_ack(hdr);
    if (!if_actim.is_running())
	if_actim.start(1*Timer::SECOND);
}
inline  void SpfIfc::if_send_dack()
{
    if_send(&if_dack, if_faddr);
}
inline void SpfIfc::if_send_update()
{
    if (if_update.iphdr)
	if_send(&if_update, if_faddr);
}
inline int SpfIfc::unnumbered() const
{
    return (if_addr == 0);
}

/* Superclasses, to describe individual interface types
 */

/* The point-to-point interface, such as serial lines. These send a single
 * copy of each multicast packet out an interface, do not elect a
 * Designated router. Neighbors are identified by their router ID.
 * Note: multicasts current sent to the IP address of the neighbor.
 * This is against the spec, but makes BSD happy.
 */

class PPIfc : public SpfIfc {
  public:
    inline PPIfc(InAddr addr, int phyint);
    virtual void ifa_start();
    virtual class SpfNbr *find_nbr(InAddr, rtid_t);
    virtual void set_id_or_addr(SpfNbr *, rtid_t, InAddr);
    virtual void if_send(Pkt *, InAddr);
    virtual void nbr_send(Pkt *, SpfNbr *);
    virtual RtrLink *rl_insert(RTRhdr *, RtrLink *);
    virtual int rl_size();
    virtual void add_adj_to_cand(class PriQ &cand);
    virtual bool more_adjacencies_needed(rtid_t);
    virtual MPath *add_parallel_links(MPath *, TNode *);
};

inline PPIfc::PPIfc(InAddr addr, int phyint) : SpfIfc(addr, phyint)
{
    if_type = IFT_PP;
}

/* A virtual link. These send a single copy of each multicast packet
 * out an interface, although as a unicast to the neighbor's IP
 * address. They do not elect a Designated router, and only a single
 * neighbor is possible, with router ID pre-configured.
 */

class VLIfc : public PPIfc {
  public:
    VLIfc(SpfArea *, class RTRrte *);
    ~VLIfc();
    virtual void ifa_start();
    virtual void if_send(Pkt *, InAddr);
    virtual void nbr_send(Pkt *, SpfNbr *);
    virtual RtrLink *rl_insert(RTRhdr *, RtrLink *);
    void update(class RTRrte *endpt);
    friend class OSPF;
    virtual bool more_adjacencies_needed(rtid_t);
    virtual MPath *add_parallel_links(MPath *, TNode *);

    inline SpfArea* transit_area() const { return if_tap; }
    inline rtid_t nbr_id() const { return if_nbrid; }
};

/* Interfaces that elect Designated Routers. The broadcast interface
 * and NBMA interfaces are derived from this class.
 */

class DRIfc : public SpfIfc {
  public:
    inline DRIfc(InAddr addr, int phyint);
    virtual int adjacency_wanted(class SpfNbr *np);
    virtual RtrLink *rl_insert(RTRhdr *, RtrLink *);
    virtual void add_adj_to_cand(class PriQ &cand);
    virtual void ifa_start();
    virtual bool elects_dr();
};

inline DRIfc::DRIfc(InAddr addr, int phyint) : SpfIfc(addr, phyint)
{
}

/* The broadcast interface, such as ethernets. These send a single
 * copy of each multicast packet out an interface, and elect a
 * Designated router. Neighbors are identified by their IP address.
 */

class BroadcastIfc : public DRIfc {
  public:
    inline BroadcastIfc(InAddr addr, int phyint);
};

inline BroadcastIfc::BroadcastIfc(InAddr addr, int phyint)
: DRIfc(addr, phyint)
{
    if_type = IFT_BROADCAST;
}

/* The NBMA interface, such full mesh-connected Frame relay subnets.
 *These send a separate packet to each neighbor. They elect a
 * Designated router, and neighbors are identified by their IP address.
 */

class NBMAIfc : public DRIfc {
  public:
    inline NBMAIfc(InAddr addr, int phyint);
    virtual void if_send(Pkt *pdesc, InAddr addr);
    virtual void start_hellos();
    virtual void restart_hellos();
    virtual void stop_hellos();
    virtual void send_hello_response(SpfNbr *np);
};

inline NBMAIfc::NBMAIfc(InAddr addr, int phyint) : DRIfc(addr, phyint)
{
    if_type = IFT_NBMA;
}

/* The point-to-Multipoint interface, such as non-full-mesh connected
 * Frame relay subnets. Separate packets are sent to each neighbor,
 * neighbors are identified by their IP addresses, and no Designated
 * router is elected fro the network.
 */

class P2mPIfc : public SpfIfc {
  public:
    inline P2mPIfc(InAddr addr, int phyint);
    virtual void if_send(Pkt *pdesc, InAddr addr);
    virtual void start_hellos();
    virtual void restart_hellos();
    virtual void stop_hellos();
    virtual int adjacency_wanted(class SpfNbr *np);
    virtual void ifa_start();
    virtual RtrLink *rl_insert(RTRhdr *, RtrLink *);
    virtual int rl_size();
    virtual void add_adj_to_cand(class PriQ &cand);
};

inline P2mPIfc::P2mPIfc(InAddr addr, int phyint) : SpfIfc(addr, phyint)
{
    if_type = IFT_P2MP;
}

/* The loopback interface. One allocated for each loopback
 * address assigned to the router. 
 * A dummy loopback interface class HostAddr::ip is created,
 * but it is not linked onto the global or per-area interface
 * lists, but is used only in multipath structures.
 */

class LoopIfc : public SpfIfc {
  public:
    LoopIfc(SpfArea *, InAddr net, InMask mask);
    ~LoopIfc();
    virtual void ifa_start();
    virtual RtrLink *rl_insert(RTRhdr *, RtrLink *);
    virtual void add_adj_to_cand(class PriQ &cand);
};