mirror of
https://gitlab.nic.cz/labs/bird.git
synced 2024-12-30 13:41:53 +00:00
802 lines
20 KiB
C
802 lines
20 KiB
C
/*
|
|
* BIRD -- Protocols
|
|
*
|
|
* (c) 1998--2000 Martin Mares <mj@ucw.cz>
|
|
*
|
|
* Can be freely distributed and used under the terms of the GNU GPL.
|
|
*/
|
|
|
|
#undef LOCAL_DEBUG
|
|
|
|
#include "nest/bird.h"
|
|
#include "nest/protocol.h"
|
|
#include "lib/resource.h"
|
|
#include "lib/lists.h"
|
|
#include "lib/event.h"
|
|
#include "lib/string.h"
|
|
#include "conf/conf.h"
|
|
#include "nest/route.h"
|
|
#include "nest/iface.h"
|
|
#include "nest/cli.h"
|
|
#include "filter/filter.h"
|
|
|
|
static pool *proto_pool;
|
|
|
|
static list protocol_list;
|
|
static list proto_list;
|
|
|
|
#define WALK_PROTO_LIST(p) do { \
|
|
node *nn; \
|
|
WALK_LIST(nn, proto_list) { \
|
|
struct proto *p = SKIP_BACK(struct proto, glob_node, nn);
|
|
#define WALK_PROTO_LIST_END } } while(0)
|
|
|
|
#define PD(pr, msg, args...) do { if (pr->debug & D_STATES) { log(L_TRACE "%s: " msg, pr->name , ## args); } } while(0)
|
|
|
|
list active_proto_list;
|
|
static list inactive_proto_list;
|
|
static list initial_proto_list;
|
|
static list flush_proto_list;
|
|
|
|
static event *proto_flush_event;
|
|
|
|
static char *p_states[] = { "DOWN", "START", "UP", "STOP" };
|
|
static char *c_states[] = { "HUNGRY", "FEEDING", "HAPPY", "FLUSHING" };
|
|
|
|
static void proto_flush_all(void *);
|
|
static void proto_rethink_goal(struct proto *p);
|
|
static char *proto_state_name(struct proto *p);
|
|
|
|
static void
|
|
proto_enqueue(list *l, struct proto *p)
|
|
{
|
|
add_tail(l, &p->n);
|
|
p->last_state_change = now;
|
|
}
|
|
|
|
static void
|
|
proto_relink(struct proto *p)
|
|
{
|
|
list *l;
|
|
|
|
if (p->debug & D_STATES)
|
|
{
|
|
char *name = proto_state_name(p);
|
|
if (name != p->last_state_name_announced)
|
|
{
|
|
p->last_state_name_announced = name;
|
|
PD(p, "State changed to %s", proto_state_name(p));
|
|
}
|
|
}
|
|
else
|
|
p->last_state_name_announced = NULL;
|
|
rem_node(&p->n);
|
|
switch (p->core_state)
|
|
{
|
|
case FS_HAPPY:
|
|
l = &active_proto_list;
|
|
break;
|
|
case FS_FLUSHING:
|
|
l = &flush_proto_list;
|
|
break;
|
|
default:
|
|
l = &inactive_proto_list;
|
|
}
|
|
proto_enqueue(l, p);
|
|
}
|
|
|
|
/**
|
|
* proto_new - create a new protocol instance
|
|
* @c: protocol configuration
|
|
* @size: size of protocol data structure (each protocol instance is represented by
|
|
* a structure starting with generic part [struct &proto] and continued
|
|
* with data specific to the protocol)
|
|
*
|
|
* When a new configuration has been read in, the core code starts
|
|
* initializing all the protocol instances configured by calling their
|
|
* init() hooks with the corresponding instance configuration. The initialization
|
|
* code of the protocol is expected to create a new instance according to the
|
|
* configuration by calling this function and then modifying the default settings
|
|
* to values wanted by the protocol.
|
|
*/
|
|
void *
|
|
proto_new(struct proto_config *c, unsigned size)
|
|
{
|
|
struct protocol *pr = c->protocol;
|
|
struct proto *p = mb_allocz(proto_pool, size);
|
|
|
|
p->cf = c;
|
|
p->debug = c->debug;
|
|
p->name = c->name;
|
|
p->preference = c->preference;
|
|
p->disabled = c->disabled;
|
|
p->proto = pr;
|
|
p->table = c->table->table;
|
|
p->in_filter = c->in_filter;
|
|
p->out_filter = c->out_filter;
|
|
p->min_scope = SCOPE_SITE;
|
|
p->hash_key = random_u32();
|
|
c->proto = p;
|
|
return p;
|
|
}
|
|
|
|
static void
|
|
proto_init_instance(struct proto *p)
|
|
{
|
|
/* Here we cannot use p->cf->name since it won't survive reconfiguration */
|
|
p->pool = rp_new(proto_pool, p->proto->name);
|
|
p->attn = ev_new(p->pool);
|
|
p->attn->data = p;
|
|
rt_lock_table(p->table);
|
|
}
|
|
|
|
/**
|
|
* proto_add_announce_hook - connect protocol to a routing table
|
|
* @p: protocol instance
|
|
* @t: routing table to connect to
|
|
*
|
|
* This function creates a connection between the protocol instance @p
|
|
* and the routing table @t, making the protocol hear all changes in
|
|
* the table.
|
|
*
|
|
* Unless you want to listen to multiple routing tables (as the Pipe
|
|
* protocol does), you needn't to worry about this function since the
|
|
* connection to the protocol's primary routing table is initialized
|
|
* automatically by the core code.
|
|
*/
|
|
struct announce_hook *
|
|
proto_add_announce_hook(struct proto *p, struct rtable *t)
|
|
{
|
|
struct announce_hook *h;
|
|
|
|
if (!p->rt_notify)
|
|
return NULL;
|
|
DBG("Connecting protocol %s to table %s\n", p->name, t->name);
|
|
PD(p, "Connected to table %s", t->name);
|
|
h = mb_alloc(p->pool, sizeof(struct announce_hook));
|
|
h->table = t;
|
|
h->proto = p;
|
|
h->next = p->ahooks;
|
|
p->ahooks = h;
|
|
add_tail(&t->hooks, &h->n);
|
|
return h;
|
|
}
|
|
|
|
static void
|
|
proto_flush_hooks(struct proto *p)
|
|
{
|
|
struct announce_hook *h;
|
|
|
|
for(h=p->ahooks; h; h=h->next)
|
|
rem_node(&h->n);
|
|
p->ahooks = NULL;
|
|
}
|
|
|
|
/**
|
|
* proto_config_new - create a new protocol configuration
|
|
* @pr: protocol the configuration will belong to
|
|
* @size: size of the structure including generic data
|
|
*
|
|
* Whenever the configuration file says that a new instance
|
|
* of a routing protocol should be created, the parser calls
|
|
* proto_config_new() to create a configuration entry for this
|
|
* instance (a structure staring with the &proto_config header
|
|
* containing all the generic items followed by protocol-specific
|
|
* ones). Also, the configuration entry gets added to the list
|
|
* of protocol instances kept in the configuration.
|
|
*/
|
|
void *
|
|
proto_config_new(struct protocol *pr, unsigned size)
|
|
{
|
|
struct proto_config *c = cfg_allocz(size);
|
|
|
|
add_tail(&new_config->protos, &c->n);
|
|
c->global = new_config;
|
|
c->protocol = pr;
|
|
c->name = pr->name;
|
|
c->out_filter = FILTER_REJECT;
|
|
c->table = c->global->master_rtc;
|
|
c->debug = new_config->proto_default_debug;
|
|
return c;
|
|
}
|
|
|
|
/**
|
|
* protos_preconfig - pre-configuration processing
|
|
* @c: new configuration
|
|
*
|
|
* This function calls the preconfig() hooks of all routing
|
|
* protocols available to prepare them for reading of the new
|
|
* configuration.
|
|
*/
|
|
void
|
|
protos_preconfig(struct config *c)
|
|
{
|
|
struct protocol *p;
|
|
|
|
init_list(&c->protos);
|
|
DBG("Protocol preconfig:");
|
|
WALK_LIST(p, protocol_list)
|
|
{
|
|
DBG(" %s", p->name);
|
|
p->name_counter = 0;
|
|
if (p->preconfig)
|
|
p->preconfig(p, c);
|
|
}
|
|
DBG("\n");
|
|
}
|
|
|
|
/**
|
|
* protos_postconfig - post-configuration processing
|
|
* @c: new configuration
|
|
*
|
|
* This function calls the postconfig() hooks of all protocol
|
|
* instances specified in configuration @c.
|
|
*/
|
|
void
|
|
protos_postconfig(struct config *c)
|
|
{
|
|
struct proto_config *x;
|
|
struct protocol *p;
|
|
|
|
DBG("Protocol postconfig:");
|
|
WALK_LIST(x, c->protos)
|
|
{
|
|
DBG(" %s", x->name);
|
|
p = x->protocol;
|
|
if (p->postconfig)
|
|
p->postconfig(x);
|
|
}
|
|
DBG("\n");
|
|
}
|
|
|
|
static struct proto *
|
|
proto_init(struct proto_config *c)
|
|
{
|
|
struct protocol *p = c->protocol;
|
|
struct proto *q = p->init(c);
|
|
|
|
q->proto_state = PS_DOWN;
|
|
q->core_state = FS_HUNGRY;
|
|
proto_enqueue(&initial_proto_list, q);
|
|
add_tail(&proto_list, &q->glob_node);
|
|
PD(q, "Initializing%s", q->disabled ? " [disabled]" : "");
|
|
return q;
|
|
}
|
|
|
|
/**
|
|
* protos_commit - commit new protocol configuration
|
|
* @new: new configuration
|
|
* @old: old configuration or %NULL if it's boot time config
|
|
* @force_reconfig: force restart of all protocols (used for example
|
|
* when the router ID changes)
|
|
*
|
|
* Scan differences between @old and @new configuration and adjust all
|
|
* protocol instances to conform to the new configuration.
|
|
*
|
|
* When a protocol exists in the new configuration, but it doesn't in the
|
|
* original one, it's immediately started. When a collision with the other
|
|
* running protocol would arise, the new protocol will be temporarily stopped
|
|
* by the locking mechanism.
|
|
*
|
|
* When a protocol exists in the old configuration, but it doesn't in the
|
|
* new one, it's shut down and deleted after the shutdown completes.
|
|
*
|
|
* When a protocol exists in both configurations, the core decides whether
|
|
* it's possible to reconfigure it dynamically (it checks all the core properties
|
|
* of the protocol and if they match, it asks the reconfigure() hook of the
|
|
* protocol to see if the protocol is able to switch to the new configuration).
|
|
* If it isn't possible, the protocol is shut down and a new instance is started
|
|
* with the new configuration after the shutdown is completed.
|
|
*/
|
|
void
|
|
protos_commit(struct config *new, struct config *old, int force_reconfig)
|
|
{
|
|
struct proto_config *oc, *nc;
|
|
struct proto *p, *n;
|
|
|
|
DBG("protos_commit:\n");
|
|
if (old)
|
|
{
|
|
WALK_LIST(oc, old->protos)
|
|
{
|
|
struct proto *p = oc->proto;
|
|
struct symbol *sym = cf_find_symbol(oc->name);
|
|
if (sym && sym->class == SYM_PROTO && !new->shutdown)
|
|
{
|
|
/* Found match, let's check if we can smoothly switch to new configuration */
|
|
nc = sym->def;
|
|
if (!force_reconfig
|
|
&& nc->protocol == oc->protocol
|
|
&& nc->preference == oc->preference
|
|
&& nc->disabled == oc->disabled
|
|
&& nc->table->table == oc->table->table
|
|
&& filter_same(nc->in_filter, oc->in_filter)
|
|
&& filter_same(nc->out_filter, oc->out_filter)
|
|
&& p->proto_state != PS_DOWN)
|
|
{
|
|
/* Generic attributes match, try converting them and then ask the protocol */
|
|
p->debug = nc->debug;
|
|
if (p->proto->reconfigure && p->proto->reconfigure(p, nc))
|
|
{
|
|
DBG("\t%s: same\n", oc->name);
|
|
PD(p, "Reconfigured");
|
|
p->cf = nc;
|
|
p->name = nc->name;
|
|
p->in_filter = nc->in_filter;
|
|
p->out_filter = nc->out_filter;
|
|
nc->proto = p;
|
|
continue;
|
|
}
|
|
}
|
|
/* Unsuccessful, force reconfig */
|
|
DBG("\t%s: power cycling\n", oc->name);
|
|
PD(p, "Reconfiguration failed, restarting");
|
|
p->cf_new = nc;
|
|
nc->proto = p;
|
|
}
|
|
else
|
|
{
|
|
DBG("\t%s: deleting\n", oc->name);
|
|
PD(p, "Unconfigured");
|
|
p->cf_new = NULL;
|
|
}
|
|
p->reconfiguring = 1;
|
|
config_add_obstacle(old);
|
|
proto_rethink_goal(p);
|
|
}
|
|
}
|
|
|
|
WALK_LIST(nc, new->protos)
|
|
if (!nc->proto)
|
|
{
|
|
DBG("\t%s: adding\n", nc->name);
|
|
proto_init(nc);
|
|
}
|
|
DBG("\tdone\n");
|
|
|
|
DBG("Protocol start\n");
|
|
WALK_LIST_DELSAFE(p, n, initial_proto_list)
|
|
proto_rethink_goal(p);
|
|
}
|
|
|
|
static void
|
|
proto_rethink_goal(struct proto *p)
|
|
{
|
|
struct protocol *q;
|
|
|
|
if (p->reconfiguring && p->core_state == FS_HUNGRY && p->proto_state == PS_DOWN)
|
|
{
|
|
struct proto_config *nc = p->cf_new;
|
|
DBG("%s has shut down for reconfiguration\n", p->name);
|
|
config_del_obstacle(p->cf->global);
|
|
rem_node(&p->n);
|
|
rem_node(&p->glob_node);
|
|
mb_free(p);
|
|
if (!nc)
|
|
return;
|
|
p = proto_init(nc);
|
|
}
|
|
|
|
/* Determine what state we want to reach */
|
|
if (p->disabled || p->reconfiguring)
|
|
{
|
|
p->core_goal = FS_HUNGRY;
|
|
if (p->core_state == FS_HUNGRY && p->proto_state == PS_DOWN)
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
p->core_goal = FS_HAPPY;
|
|
if (p->core_state == FS_HAPPY && p->proto_state == PS_UP)
|
|
return;
|
|
}
|
|
|
|
q = p->proto;
|
|
if (p->core_goal == FS_HAPPY) /* Going up */
|
|
{
|
|
if (p->core_state == FS_HUNGRY && p->proto_state == PS_DOWN)
|
|
{
|
|
DBG("Kicking %s up\n", p->name);
|
|
PD(p, "Starting");
|
|
proto_init_instance(p);
|
|
proto_notify_state(p, (q->start ? q->start(p) : PS_UP));
|
|
}
|
|
}
|
|
else /* Going down */
|
|
{
|
|
if (p->proto_state == PS_START || p->proto_state == PS_UP)
|
|
{
|
|
DBG("Kicking %s down\n", p->name);
|
|
PD(p, "Shutting down");
|
|
proto_notify_state(p, (q->shutdown ? q->shutdown(p) : PS_DOWN));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* protos_dump_all - dump status of all protocols
|
|
*
|
|
* This function dumps status of all existing protocol instances to the
|
|
* debug output. It involves printing of general status information
|
|
* such as protocol states, its position on the protocol lists
|
|
* and also calling of a dump() hook of the protocol to print
|
|
* the internals.
|
|
*/
|
|
void
|
|
protos_dump_all(void)
|
|
{
|
|
struct proto *p;
|
|
|
|
debug("Protocols:\n");
|
|
|
|
WALK_LIST(p, active_proto_list)
|
|
{
|
|
debug(" protocol %s state %s/%s\n", p->name,
|
|
p_states[p->proto_state], c_states[p->core_state]);
|
|
if (p->in_filter)
|
|
debug("\tInput filter: %s\n", filter_name(p->in_filter));
|
|
if (p->out_filter != FILTER_REJECT)
|
|
debug("\tOutput filter: %s\n", filter_name(p->out_filter));
|
|
if (p->disabled)
|
|
debug("\tDISABLED\n");
|
|
else if (p->proto->dump)
|
|
p->proto->dump(p);
|
|
}
|
|
WALK_LIST(p, inactive_proto_list)
|
|
debug(" inactive %s: state %s/%s\n", p->name, p_states[p->proto_state], c_states[p->core_state]);
|
|
WALK_LIST(p, initial_proto_list)
|
|
debug(" initial %s\n", p->name);
|
|
WALK_LIST(p, flush_proto_list)
|
|
debug(" flushing %s\n", p->name);
|
|
}
|
|
|
|
/**
|
|
* proto_build - make a single protocol available
|
|
* @p: the protocol
|
|
*
|
|
* After the platform specific initialization code uses protos_build()
|
|
* to add all the standard protocols, it should call proto_build() for
|
|
* all platform specific protocols to inform the core that they exist.
|
|
*/
|
|
void
|
|
proto_build(struct protocol *p)
|
|
{
|
|
add_tail(&protocol_list, &p->n);
|
|
if (p->attr_class)
|
|
{
|
|
ASSERT(!attr_class_to_protocol[p->attr_class]);
|
|
attr_class_to_protocol[p->attr_class] = p;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* protos_build - build a protocol list
|
|
*
|
|
* This function is called during BIRD startup to insert
|
|
* all standard protocols to the global protocol list. Insertion
|
|
* of platform specific protocols (such as the kernel syncer)
|
|
* is in the domain of competence of the platform dependent
|
|
* startup code.
|
|
*/
|
|
void
|
|
protos_build(void)
|
|
{
|
|
init_list(&protocol_list);
|
|
init_list(&proto_list);
|
|
init_list(&active_proto_list);
|
|
init_list(&inactive_proto_list);
|
|
init_list(&initial_proto_list);
|
|
init_list(&flush_proto_list);
|
|
proto_build(&proto_device);
|
|
#ifdef CONFIG_RIP
|
|
proto_build(&proto_rip);
|
|
#endif
|
|
#ifdef CONFIG_STATIC
|
|
proto_build(&proto_static);
|
|
#endif
|
|
#ifdef CONFIG_OSPF
|
|
proto_build(&proto_ospf);
|
|
#endif
|
|
#ifdef CONFIG_PIPE
|
|
proto_build(&proto_pipe);
|
|
#endif
|
|
#ifdef CONFIG_BGP
|
|
proto_build(&proto_bgp);
|
|
#endif
|
|
proto_pool = rp_new(&root_pool, "Protocols");
|
|
proto_flush_event = ev_new(proto_pool);
|
|
proto_flush_event->hook = proto_flush_all;
|
|
}
|
|
|
|
static void
|
|
proto_fell_down(struct proto *p)
|
|
{
|
|
DBG("Protocol %s down\n", p->name);
|
|
rt_unlock_table(p->table);
|
|
proto_rethink_goal(p);
|
|
}
|
|
|
|
static void
|
|
proto_feed_more(void *P)
|
|
{
|
|
struct proto *p = P;
|
|
|
|
DBG("Feeding protocol %s continued\n", p->name);
|
|
if (p->core_state != FS_FEEDING)
|
|
return;
|
|
if (rt_feed_baby(p))
|
|
{
|
|
p->core_state = FS_HAPPY;
|
|
proto_relink(p);
|
|
DBG("Protocol %s up and running\n", p->name);
|
|
}
|
|
else
|
|
{
|
|
p->attn->hook = proto_feed_more;
|
|
ev_schedule(p->attn); /* Will continue later... */
|
|
}
|
|
}
|
|
|
|
static void
|
|
proto_feed(void *P)
|
|
{
|
|
struct proto *p = P;
|
|
|
|
DBG("Feeding protocol %s\n", p->name);
|
|
proto_add_announce_hook(p, p->table);
|
|
if_feed_baby(p);
|
|
proto_feed_more(P);
|
|
}
|
|
|
|
/**
|
|
* proto_notify_state - notify core about protocol state change
|
|
* @p: protocol the state of which has changed
|
|
* @ps: the new status
|
|
*
|
|
* Whenever a state of a protocol changes due to some event internal
|
|
* to the protocol (i.e., not inside a start() or shutdown() hook),
|
|
* it should immediately notify the core about the change by calling
|
|
* proto_notify_state() which will write the new state to the &proto
|
|
* structure and take all the actions necessary to adapt to the new
|
|
* state.
|
|
*/
|
|
void
|
|
proto_notify_state(struct proto *p, unsigned ps)
|
|
{
|
|
unsigned ops = p->proto_state;
|
|
unsigned cs = p->core_state;
|
|
|
|
DBG("%s reporting state transition %s/%s -> */%s\n", p->name, c_states[cs], p_states[ops], p_states[ps]);
|
|
if (ops == ps)
|
|
return;
|
|
|
|
switch (ps)
|
|
{
|
|
case PS_DOWN:
|
|
if (cs == FS_HUNGRY) /* Shutdown finished */
|
|
{
|
|
p->proto_state = ps;
|
|
proto_fell_down(p);
|
|
return; /* The protocol might have ceased to exist */
|
|
}
|
|
else if (cs == FS_FLUSHING) /* Still flushing... */
|
|
;
|
|
else
|
|
{
|
|
if (cs == FS_FEEDING) /* Need to abort feeding */
|
|
rt_feed_baby_abort(p);
|
|
goto schedule_flush; /* Need to start flushing */
|
|
}
|
|
break;
|
|
case PS_START:
|
|
ASSERT(ops == PS_DOWN);
|
|
ASSERT(cs == FS_HUNGRY);
|
|
break;
|
|
case PS_UP:
|
|
ASSERT(ops == PS_DOWN || ops == PS_START);
|
|
ASSERT(cs == FS_HUNGRY);
|
|
DBG("%s: Scheduling meal\n", p->name);
|
|
cs = FS_FEEDING;
|
|
p->attn->hook = proto_feed;
|
|
ev_schedule(p->attn);
|
|
break;
|
|
case PS_STOP:
|
|
if (ops != PS_DOWN)
|
|
{
|
|
schedule_flush:
|
|
DBG("%s: Scheduling flush\n", p->name);
|
|
proto_flush_hooks(p);
|
|
cs = FS_FLUSHING;
|
|
ev_schedule(proto_flush_event);
|
|
}
|
|
break;
|
|
default:
|
|
bug("Invalid state transition for %s from %s/%s to */%s", p->name, c_states[cs], p_states[ops], p_states[ps]);
|
|
}
|
|
p->proto_state = ps;
|
|
p->core_state = cs;
|
|
proto_relink(p);
|
|
}
|
|
|
|
static void
|
|
proto_flush_all(void *unused UNUSED)
|
|
{
|
|
struct proto *p;
|
|
|
|
rt_prune_all();
|
|
neigh_prune();
|
|
while ((p = HEAD(flush_proto_list))->n.next)
|
|
{
|
|
DBG("Flushing protocol %s\n", p->name);
|
|
rfree(p->pool);
|
|
p->pool = NULL;
|
|
p->core_state = FS_HUNGRY;
|
|
proto_relink(p);
|
|
proto_fell_down(p);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* CLI Commands
|
|
*/
|
|
|
|
static char *
|
|
proto_state_name(struct proto *p)
|
|
{
|
|
#define P(x,y) ((x << 4) | y)
|
|
switch (P(p->proto_state, p->core_state))
|
|
{
|
|
case P(PS_DOWN, FS_HUNGRY): return "down";
|
|
case P(PS_START, FS_HUNGRY): return "start";
|
|
case P(PS_UP, FS_HUNGRY):
|
|
case P(PS_UP, FS_FEEDING): return "feed";
|
|
case P(PS_STOP, FS_HUNGRY): return "stop";
|
|
case P(PS_UP, FS_HAPPY): return "up";
|
|
case P(PS_STOP, FS_FLUSHING):
|
|
case P(PS_DOWN, FS_FLUSHING): return "flush";
|
|
default: return "???";
|
|
}
|
|
#undef P
|
|
}
|
|
|
|
static void
|
|
proto_do_show(struct proto *p, int verbose)
|
|
{
|
|
byte buf[256], reltime[TM_RELTIME_BUFFER_SIZE];
|
|
|
|
buf[0] = 0;
|
|
if (p->proto->get_status)
|
|
p->proto->get_status(p, buf);
|
|
tm_format_reltime(reltime, p->last_state_change);
|
|
cli_msg(-1002, "%-8s %-8s %-8s %-5s %-5s %s",
|
|
p->name,
|
|
p->proto->name,
|
|
p->table->name,
|
|
proto_state_name(p),
|
|
reltime,
|
|
buf);
|
|
if (verbose)
|
|
{
|
|
cli_msg(-1006, "\tPreference: %d", p->preference);
|
|
cli_msg(-1006, "\tInput filter: %s", filter_name(p->in_filter));
|
|
cli_msg(-1006, "\tOutput filter: %s", filter_name(p->out_filter));
|
|
}
|
|
}
|
|
|
|
void
|
|
proto_show(struct symbol *s, int verbose)
|
|
{
|
|
if (s && s->class != SYM_PROTO)
|
|
{
|
|
cli_msg(9002, "%s is not a protocol", s->name);
|
|
return;
|
|
}
|
|
cli_msg(-2002, "name proto table state since info");
|
|
if (s)
|
|
proto_do_show(((struct proto_config *)s->def)->proto, verbose);
|
|
else
|
|
{
|
|
WALK_PROTO_LIST(p)
|
|
proto_do_show(p, verbose);
|
|
WALK_PROTO_LIST_END;
|
|
}
|
|
cli_msg(0, "");
|
|
}
|
|
|
|
struct proto *
|
|
proto_get_named(struct symbol *sym, struct protocol *pr)
|
|
{
|
|
struct proto *p, *q;
|
|
|
|
if (sym)
|
|
{
|
|
if (sym->class != SYM_PROTO)
|
|
cf_error("%s: Not a protocol", sym->name);
|
|
p = ((struct proto_config *)sym->def)->proto;
|
|
if (!p || p->proto != pr)
|
|
cf_error("%s: Not a %s protocol", sym->name, pr->name);
|
|
}
|
|
else
|
|
{
|
|
p = NULL;
|
|
WALK_LIST(q, active_proto_list)
|
|
if (q->proto == pr)
|
|
{
|
|
if (p)
|
|
cf_error("There are multiple %s protocols running", pr->name);
|
|
p = q;
|
|
}
|
|
if (!p)
|
|
cf_error("There is no %s protocol running", pr->name);
|
|
}
|
|
return p;
|
|
}
|
|
|
|
void
|
|
proto_xxable(char *pattern, int xx)
|
|
{
|
|
int cnt = 0;
|
|
WALK_PROTO_LIST(p)
|
|
if (patmatch(pattern, p->name))
|
|
{
|
|
cnt++;
|
|
switch (xx)
|
|
{
|
|
case 0:
|
|
if (p->disabled)
|
|
cli_msg(-8, "%s: already disabled", p->name);
|
|
else
|
|
{
|
|
cli_msg(-9, "%s: disabled", p->name);
|
|
p->disabled = 1;
|
|
}
|
|
break;
|
|
case 1:
|
|
if (!p->disabled)
|
|
cli_msg(-10, "%s: already enabled", p->name);
|
|
else
|
|
{
|
|
cli_msg(-11, "%s: enabled", p->name);
|
|
p->disabled = 0;
|
|
}
|
|
break;
|
|
case 2:
|
|
if (p->disabled)
|
|
cli_msg(-8, "%s: already disabled", p->name);
|
|
else
|
|
{
|
|
p->disabled = 1;
|
|
proto_rethink_goal(p);
|
|
p->disabled = 0;
|
|
cli_msg(-12, "%s: restarted", p->name);
|
|
}
|
|
break;
|
|
default:
|
|
ASSERT(0);
|
|
}
|
|
proto_rethink_goal(p);
|
|
}
|
|
WALK_PROTO_LIST_END;
|
|
if (!cnt)
|
|
cli_msg(8003, "No protocols match");
|
|
else
|
|
cli_msg(0, "");
|
|
}
|
|
|
|
void
|
|
proto_debug(char *pattern, unsigned int mask)
|
|
{
|
|
int cnt = 0;
|
|
WALK_PROTO_LIST(p)
|
|
if (patmatch(pattern, p->name))
|
|
{
|
|
cnt++;
|
|
p->debug = mask;
|
|
}
|
|
WALK_PROTO_LIST_END;
|
|
if (!cnt)
|
|
cli_msg(8003, "No protocols match");
|
|
else
|
|
cli_msg(0, "");
|
|
}
|