bird/nest/proto-hooks.c
Ondrej Zajicek dca75fd7c2 Removes phantom protocol from the pipe design.
It seems that by adding one pipe-specific exception to route
announcement code and by adding one argument to rt_notify() callback i
could completely eliminate the need for the phantom protocol instance
and therefore make the code more straightforward. It will also fix some
minor bugs (like ignoring debug flag changes from the command line).
2010-02-13 12:26:26 +01:00

324 lines
10 KiB
C

/*
* BIRD -- Documentation for Protocol Hooks (dummy source file)
*
* (c) 2000 Martin Mares <mj@ucw.cz>
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: Protocol hooks
*
* Each protocol can provide a rich set of hook functions referred to by pointers
* in either the &proto or &protocol structure. They are called by the core whenever
* it wants the protocol to perform some action or to notify the protocol about
* any change of its environment. All of the hooks can be set to %NULL which means
* to ignore the change or to take a default action.
*/
/**
* preconfig - protocol preconfiguration
* @p: a routing protocol
* @c: new configuration
*
* The preconfig() hook is called before parsing of a new configuration.
*/
void preconfig(struct protocol *p, struct config *c)
{ DUMMY; }
/**
* postconfig - instance post-configuration
* @c: instance configuration
*
* The postconfig() hook is called for each configured instance after
* parsing of the new configuration is finished.
*/
void postconfig(struct proto_config *c)
{ DUMMY; }
/**
* init - initialize an instance
* @c: instance configuration
*
* The init() hook is called by the core to create a protocol instance
* according to supplied protocol configuration.
*
* Result: a pointer to the instance created
*/
struct proto *init(struct proto_config *c)
{ DUMMY; }
/**
* reconfigure - request instance reconfiguration
* @p: an instance
* @c: new configuration
*
* The core calls the reconfigure() hook whenever it wants to ask the
* protocol for switching to a new configuration. If the reconfiguration
* is possible, the hook returns 1. Otherwise, it returns 0 and the core
* will shut down the instance and start a new one with the new configuration.
*
* After the protocol confirms reconfiguration, it must no longer keep any
* references to the old configuration since the memory it's stored in can
* be re-used at any time.
*/
int reconfigure(struct proto *p, struct proto_config *c)
{ DUMMY; }
/**
* dump - dump protocol state
* @p: an instance
*
* This hook dumps the complete state of the instance to the
* debug output.
*/
void dump(struct proto *p)
{ DUMMY; }
/**
* dump_attrs - dump protocol-dependent attributes
* @e: a route entry
*
* This hook dumps all attributes in the &rte which belong to this
* protocol to the debug output.
*/
void dump_attrs(rte *e)
{ DUMMY; }
/**
* start - request instance startup
* @p: protocol instance
*
* The start() hook is called by the core when it wishes to start
* the instance.
*
* Result: new protocol state
*/
int start(struct proto *p)
{ DUMMY; }
/**
* shutdown - request instance shutdown
* @p: protocol instance
*
* The stop() hook is called by the core when it wishes to shut
* the instance down for some reason.
*
* Returns: new protocol state
*/
int shutdown(struct proto *p)
{ DUMMY; }
/**
* get_status - get instance status
* @p: protocol instance
* @buf: buffer to be filled with the status string
*
* This hook is called by the core if it wishes to obtain an brief one-line user friendly
* representation of the status of the instance to be printed by the <cf/show protocols/
* command.
*/
void get_status(struct proto *p, byte *buf)
{ DUMMY; }
/**
* get_route_info - get route information
* @e: a route entry
* @buf: buffer to be filled with the resulting string
* @attrs: extended attributes of the route
*
* This hook is called to fill the buffer @buf with a brief user friendly
* representation of metrics of a route belonging to this protocol.
*/
void get_route_info(rte *e, byte *buf, ea_list *attrs)
{ DUMMY; }
/**
* get_attr - get attribute information
* @a: an extended attribute
* @buf: buffer to be filled with attribute information
*
* The get_attr() hook is called by the core to obtain a user friendly
* representation of an extended route attribute. It can either leave
* the whole conversion to the core (by returning %GA_UNKNOWN), fill
* in only attribute name (and let the core format the attribute value
* automatically according to the type field; by returning %GA_NAME)
* or doing the whole conversion (used in case the value requires extra
* care; return %GA_FULL).
*/
int get_attr(eattr *a, byte *buf, int buflen)
{ DUMMY; }
/**
* if_notify - notify instance about interface changes
* @p: protocol instance
* @flags: interface change flags
* @i: the interface in question
*
* This hook is called whenever any network interface changes its status.
* The change is described by a combination of status bits (%IF_CHANGE_xxx)
* in the @flags parameter.
*/
void if_notify(struct proto *p, unsigned flags, struct iface *i)
{ DUMMY; }
/**
* ifa_notify - notify instance about interface address changes
* @p: protocol instance
* @flags: address change flags
* @a: the interface address
*
* This hook is called to notify the protocol instance about an interface
* acquiring or losing one of its addresses. The change is described by
* a combination of status bits (%IF_CHANGE_xxx) in the @flags parameter.
*/
void ifa_notify(struct proto *p, unsigned flags, struct ifa *a)
{ DUMMY; }
/**
* rt_notify - notify instance about routing table change
* @p: protocol instance
* @table: a routing table
* @net: a network entry
* @new: new route for the network
* @old: old route for the network
* @attrs: extended attributes associated with the @new entry
*
* The rt_notify() hook is called to inform the protocol instance about
* changes in the connected routing table @table, that is a route @old
* belonging to network @net being replaced by a new route @new with
* extended attributes @attrs. Either @new or @old or both can be %NULL
* if the corresponding route doesn't exist.
*
* If the type of route announcement is RA_OPTIMAL, it is an
* announcement of optimal route change, @new stores the new optimal
* route and @old stores the old optimal route.
*
* If the type of route announcement is RA_ANY, it is an announcement
* of any route change, @new stores the new route and @old stores the
* old route from the same protocol.
*
* @p->accept_ra_types specifies which kind of route announcements
* protocol wants to receive.
*/
void rt_notify(struct proto *p, net *net, rte *new, rte *old, ea_list *attrs)
{ DUMMY; }
/**
* neigh_notify - notify instance about neighbor status change
* @neigh: a neighbor cache entry
*
* The neigh_notify() hook is called by the neighbor cache whenever
* a neighbor changes its state, that is it gets disconnected or a
* sticky neighbor gets connected.
*/
void neigh_notify(neighbor *neigh)
{ DUMMY; }
/**
* make_tmp_attrs - convert embedded attributes to temporary ones
* @e: route entry
* @pool: linear pool to allocate attribute memory in
*
* This hook is called by the routing table functions if they need
* to convert the protocol attributes embedded directly in the &rte
* to temporary extended attributes in order to distribute them
* to other protocols or to filters. make_tmp_attrs() creates
* an &ea_list in the linear pool @pool, fills it with values of the
* temporary attributes and returns a pointer to it.
*/
ea_list *make_tmp_attrs(rte *e, struct linpool *pool)
{ DUMMY; }
/**
* store_tmp_attrs - convert temporary attributes to embedded ones
* @e: route entry
* @attrs: temporary attributes to be converted
*
* This hook is an exact opposite of make_tmp_attrs() -- it takes
* a list of extended attributes and converts them to attributes
* embedded in the &rte corresponding to this protocol.
*
* You must be prepared for any of the attributes being missing
* from the list and use default values instead.
*/
void store_tmp_attrs(rte *e, ea_list *attrs)
{ DUMMY; }
/**
* import_control - pre-filtering decisions on route import
* @p: protocol instance the route is going to be imported to
* @e: the route in question
* @attrs: extended attributes of the route
* @pool: linear pool for allocation of all temporary data
*
* The import_control() hook is called as the first step of a exporting
* a route from a routing table to the protocol instance. It can modify
* route attributes and force acceptance or rejection of the route regardless
* of user-specified filters. See rte_announce() for a complete description
* of the route distribution process.
*
* The standard use of this hook is to reject routes having originated
* from the same instance and to set default values of the protocol's metrics.
*
* Result: -1 if the route has to be accepted, 1 if rejected and 0 if it
* should be passed to the filters.
*/
int import_control(struct proto *p, rte **e, ea_list **attrs, struct linpool *pool)
{ DUMMY; }
/**
* rte_better - compare metrics of two routes
* @new: the new route
* @old: the original route
*
* This hook gets called when the routing table contains two routes
* for the same network which have originated from different instances
* of a single protocol and it wants to select which one is preferred
* over the other one. Protocols usually decide according to route metrics.
*
* Result: 1 if @new is better (more preferred) than @old, 0 otherwise.
*/
int rte_better(rte *new, rte *old)
{ DUMMY; }
/**
* rte_same - compare two routes
* @e1: route
* @e2: route
*
* The rte_same() hook tests whether the routes @e1 and @e2 belonging
* to the same protocol instance have identical contents. Contents of
* &rta, all the extended attributes and &rte preference are checked
* by the core code, no need to take care of them here.
*
* Result: 1 if @e1 is identical to @e2, 0 otherwise.
*/
int rte_same(rte *e1, rte *e2)
{ DUMMY; }
/**
* rte_insert - notify instance about route insertion
* @n: network
* @e: route
*
* This hook is called whenever a &rte belonging to the instance
* is accepted for insertion to a routing table.
*
* Please avoid using this function in new protocols.
*/
void rte_insert(net *n, rte *e)
{ DUMMY; }
/**
* rte_remove - notify instance about route removal
* @n: network
* @e: route
*
* This hook is called whenever a &rte belonging to the instance
* is removed from a routing table.
*
* Please avoid using this function in new protocols.
*/
void rte_remove(net *n, rte *e)
{ DUMMY; }