router.hh

Click is a modular router toolkit. To use it you ll need to know how to compile and install the sof

// -*- c-basic-offset: 4; related-file-name: "../../lib/router.cc" -*-
#ifndef CLICK_ROUTER_HH
#define CLICK_ROUTER_HH
#include <click/element.hh>
#include <click/timer.hh>
#include <click/sync.hh>
#include <click/task.hh>
#include <click/standard/threadsched.hh>
#if CLICK_NS
# include <click/simclick.h>
#endif
CLICK_DECLS
class Master;
class ElementFilter;
class RouterThread;
class HashMap_ArenaFactory;
class NotifierSignal;
class ThreadSched;
class Handler;
class NameInfo;

class Router { public:

    /** @name Public Member Functions */
    //@{
    // MASTER
    inline Master* master() const;

    // STATUS
    inline bool initialized() const;
    inline bool handlers_ready() const;
    inline bool running() const;

    // RUNCOUNT AND RUNCLASS
    enum { STOP_RUNCOUNT = -2147483647 - 1 };
    inline int32_t runcount() const;
    void adjust_runcount(int32_t delta);
    void set_runcount(int32_t rc);
    inline void please_stop_driver();

    // ELEMENTS
    inline const Vector<Element*>& elements() const;
    inline int nelements() const;
    inline Element* element(int i) const;
    inline Element* root_element() const;
    static Element* element(const Router *router, int i);

    const String& ename(int i) const;
    const String& elandmark(int i) const;
    const String& econfiguration(int i) const;
    void set_econfiguration(int i, const String& conf);

    Element* find(const String& name, ErrorHandler* errh = 0) const;
    Element* find(const String& name, String context, ErrorHandler* errh = 0) const;
    Element* find(const String& name, const Element* context, ErrorHandler* errh = 0) const;

    int downstream_elements(Element* e, int port, ElementFilter* filter, Vector<Element*>& result);
    int upstream_elements(Element* e, int port, ElementFilter* filter, Vector<Element*>& result);

    inline const char *flow_code_override(int eindex) const;
    void set_flow_code_override(int eindex, const String &flow_code);

    // HANDLERS
    // 'const Handler *' results last until that element/handlername modified
    static const Handler *handler(const Element *e, const String &hname);
    static void add_read_handler(const Element *e, const String &hname, ReadHandlerCallback callback, void *user_data, uint32_t flags = 0);
    static void add_write_handler(const Element *e, const String &hname, WriteHandlerCallback callback, void *user_data, uint32_t flags = 0);
    static void set_handler(const Element *e, const String &hname, uint32_t flags, HandlerCallback callback, void *user_data1 = 0, void *user_data2 = 0);
    static int set_handler_flags(const Element *e, const String &hname, uint32_t set_flags, uint32_t clear_flags = 0);

    enum { FIRST_GLOBAL_HANDLER = 0x40000000 };
    static int hindex(const Element *e, const String &hname);
    static const Handler *handler(const Router *router, int hindex);
    static void element_hindexes(const Element *e, Vector<int> &result);

    // ATTACHMENTS AND REQUIREMENTS
    void* attachment(const String& aname) const;
    void*& force_attachment(const String& aname);
    void* set_attachment(const String& aname, void* value);

    ErrorHandler* chatter_channel(const String& channel_name) const;
    HashMap_ArenaFactory* arena_factory() const;

    inline ThreadSched* thread_sched() const;
    inline void set_thread_sched(ThreadSched* scheduler);
    inline int initial_home_thread_id(Task* task, bool scheduled) const;

    /** @cond never */
    // Needs to be public for NameInfo, but not useful outside
    inline NameInfo* name_info() const;
    NameInfo* force_name_info();
    /** @endcond never */

    // UNPARSING
    inline const String& configuration_string() const;
    void unparse(StringAccum& sa, const String& indent = String()) const;
    void unparse_requirements(StringAccum& sa, const String& indent = String()) const;
    void unparse_declarations(StringAccum& sa, const String& indent = String()) const;
    void unparse_connections(StringAccum& sa, const String& indent = String()) const;

    String element_ports_string(const Element *e) const;
    //@}

    // INITIALIZATION
    /** @name Internal Functions */
    //@{
    Router(const String& configuration, Master* master);
    ~Router();

    static void static_initialize();
    static void static_cleanup();

    inline void use();
    void unuse();

    inline const Vector<String>& requirements() const;
    void add_requirement(const String& requirement);
    int add_element(Element* e, const String& name, const String& conf, const String& landmark);
    int add_connection(int from_idx, int from_port, int to_idx, int to_port);
#if CLICK_LINUXMODULE
    int add_module_ref(struct module* module);
#endif

    inline Router* hotswap_router() const;
    void set_hotswap_router(Router* router);

    int initialize(ErrorHandler* errh);
    void activate(bool foreground, ErrorHandler* errh);
    inline void activate(ErrorHandler* errh);

    int new_notifier_signal(const char *name, NotifierSignal &signal);
    String notifier_signal_name(const atomic_uint32_t *signal) const;
    //@}

    /** @cond never */
    // Needs to be public for Lexer, etc., but not useful outside
    struct Port {
	int idx;
	int port;

	Port() {
	}
	Port(int i, int p)
	    : idx(i), port(p) {
	}

	bool operator==(const Port &x) const {
	    return idx == x.idx && port == x.port;
	}
	bool operator!=(const Port &x) const {
	    return idx != x.idx || port != x.port;
	}
	bool operator<(const Port &x) const {
	    return idx < x.idx || (idx == x.idx && port < x.port);
	}
	bool operator<=(const Port &x) const {
	    return idx < x.idx || (idx == x.idx && port <= x.port);
	}
    };

    struct Connection {
	Port p[2];

	Connection() {
	}
	Connection(int from_idx, int from_port, int to_idx, int to_port) {
	    p[0] = Port(to_idx, to_port);
	    p[1] = Port(from_idx, from_port);
	}

	const Port &operator[](int i) const {
	    assert(i >= 0 && i < 2);
	    return p[i];
	}
	Port &operator[](int i) {
	    assert(i >= 0 && i < 2);
	    return p[i];
	}

	bool operator==(const Connection &x) const {
	    return p[0] == x.p[0] && p[1] == x.p[1];
	}
	bool operator<(const Connection &x) const {
	    return p[0] < x.p[0] || (p[0] == x.p[0] && p[1] < x.p[1]);
	}
    };
    /** @endcond never */

#if CLICK_NS
    simclick_node_t *simnode() const;
    int sim_get_ifid(const char* ifname);
    int sim_listen(int ifid, int element);
    int sim_if_ready(int ifid);
    int sim_write(int ifid, int ptype, const unsigned char *, int len,
		  simclick_simpacketinfo *pinfo);
    int sim_incoming_packet(int ifid, int ptype, const unsigned char *,
			    int len, simclick_simpacketinfo* pinfo);
    void sim_trace(const char* event);
    int sim_get_node_id();
    int sim_get_next_pkt_id();

  protected:
    Vector<Vector<int> *> _listenvecs;
    Vector<int>* sim_listenvec(int ifid);
#endif

  private:

    class RouterContextErrh;

    enum {
	ROUTER_NEW, ROUTER_PRECONFIGURE, ROUTER_PREINITIALIZE,
	ROUTER_LIVE, ROUTER_DEAD		// order is important
    };
    enum {
	RUNNING_DEAD = -2, RUNNING_INACTIVE = -1, RUNNING_PREPARING = 0,
	RUNNING_BACKGROUND = 1, RUNNING_ACTIVE = 2
    };

    Master* _master;

    atomic_uint32_t _runcount;

    atomic_uint32_t _refcount;

    Vector<Element*> _elements;
    Vector<String> _element_names;
    Vector<String> _element_configurations;
    Vector<String> _element_landmarks;

    mutable Vector<int> _element_name_sorter;
    Vector<int> _element_gport_offset[2];
    Vector<int> _element_configure_order;

    Vector<Connection> _conn;
    Vector<int> _conn_output_sorter;

    Vector<String> _requirements;

    volatile int _state;
    bool _have_connections : 1;
    bool _conn_sorted : 1;
    volatile int _running;

    Vector<int> _ehandler_first_by_element;
    Vector<int> _ehandler_to_handler;
    Vector<int> _ehandler_next;

    Vector<int> _handler_first_by_name;

    enum { HANDLER_BUFSIZ = 256 };
    Handler** _handler_bufs;
    int _nhandlers_bufs;
    int _free_handler;

    Vector<String> _attachment_names;
    Vector<void*> _attachments;

    Element* _root_element;
    String _configuration;

    struct notifier_signals_t {
	enum { capacity = 4096 };
	String name;
	int nsig;
	atomic_uint32_t sig[capacity / 32];
	notifier_signals_t *next;
	notifier_signals_t(const String &n, notifier_signals_t *nx)
	    : name(n), nsig(0), next(nx) {
	}
    };
    notifier_signals_t *_notifier_signals;
    HashMap_ArenaFactory* _arena_factory;
    Router* _hotswap_router;
    ThreadSched* _thread_sched;
    mutable NameInfo* _name_info;
    Vector<int> _flow_code_override_eindex;
    Vector<String> _flow_code_override;

    Router* _next_router;