proto.c 43.7 KB
Newer Older
1 2 3
/*
 *	BIRD -- Protocols
 *
4
 *	(c) 1998--2000 Martin Mares <mj@ucw.cz>
5 6 7 8
 *
 *	Can be freely distributed and used under the terms of the GNU GPL.
 */

9
#undef LOCAL_DEBUG
10

11 12 13 14
#include "nest/bird.h"
#include "nest/protocol.h"
#include "lib/resource.h"
#include "lib/lists.h"
15
#include "lib/event.h"
16
#include "lib/string.h"
17
#include "conf/conf.h"
18 19
#include "nest/route.h"
#include "nest/iface.h"
20
#include "nest/cli.h"
21
#include "filter/filter.h"
22

23
pool *proto_pool;
24

25
static list protocol_list;
26
static list proto_list;
27

28 29
#define PD(pr, msg, args...) do { if (pr->debug & D_STATES) { log(L_TRACE "%s: " msg, pr->name , ## args); } } while(0)

30
list active_proto_list;
31 32
static list inactive_proto_list;
static list initial_proto_list;
33
static list flush_proto_list;
34
static struct proto *initial_device_proto;
35 36

static event *proto_flush_event;
37
static timer *proto_shutdown_timer;
38 39 40 41 42 43 44 45 46
static timer *gr_wait_timer;

#define GRS_NONE	0
#define GRS_INIT	1
#define GRS_ACTIVE	2
#define GRS_DONE	3

static int graceful_restart_state;
static u32 graceful_restart_locks;
47 48

static char *p_states[] = { "DOWN", "START", "UP", "STOP" };
49
static char *c_states[] = { "HUNGRY", "???", "HAPPY", "FLUSHING" };
50

51
static void proto_flush_loop(void *);
52
static void proto_shutdown_loop(struct timer *);
53
static void proto_rethink_goal(struct proto *p);
54 55
static void proto_want_export_up(struct proto *p);
static void proto_fell_down(struct proto *p);
56
static char *proto_state_name(struct proto *p);
57

58
static void
59
proto_relink(struct proto *p)
60
{
61
  list *l = NULL;
62 63 64

  switch (p->core_state)
    {
65 66 67
    case FS_HUNGRY:
      l = &inactive_proto_list;
      break;
68
    case FS_HAPPY:
69
      l = &active_proto_list;
70 71 72 73 74
      break;
    case FS_FLUSHING:
      l = &flush_proto_list;
      break;
    default:
75
      ASSERT(0);
76
    }
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

  rem_node(&p->n);
  add_tail(l, &p->n);
}

static void
proto_log_state_change(struct proto *p)
{
  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;
96
}
97

98

99 100 101 102 103 104 105 106
/**
 * 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
107
 * initializing all the protocol instances configured by calling their
108 109 110 111 112
 * 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.
 */
113
void *
114
proto_new(struct proto_config *c, unsigned size)
115
{
116
  struct protocol *pr = c->protocol;
117
  struct proto *p = mb_allocz(proto_pool, size);
118

119 120
  p->cf = c;
  p->debug = c->debug;
121
  p->mrtdump = c->mrtdump;
122
  p->name = c->name;
123 124
  p->preference = c->preference;
  p->disabled = c->disabled;
125
  p->proto = pr;
126
  p->table = c->table->table;
127
  p->hash_key = random_u32();
128
  c->proto = p;
129 130 131
  return p;
}

132 133 134
static void
proto_init_instance(struct proto *p)
{
135 136
  /* Here we cannot use p->cf->name since it won't survive reconfiguration */
  p->pool = rp_new(proto_pool, p->proto->name);
137 138
  p->attn = ev_new(p->pool);
  p->attn->data = p;
139

140 141 142
  if (graceful_restart_state == GRS_INIT)
    p->gr_recovery = 1;

143 144
  if (! p->proto->multitable)
    rt_lock_table(p->table);
145 146
}

147
extern pool *rt_table_pool;
148 149 150 151
/**
 * proto_add_announce_hook - connect protocol to a routing table
 * @p: protocol instance
 * @t: routing table to connect to
152
 * @stats: per-table protocol statistics
153
 *
154 155
 * This function creates a connection between the protocol instance @p and the
 * routing table @t, making the protocol hear all changes in the table.
156
 *
157 158 159 160 161 162
 * The announce hook is linked in the protocol ahook list. Announce hooks are
 * allocated from the routing table resource pool and when protocol accepts
 * routes also in the table ahook list. The are linked to the table ahook list
 * and unlinked from it depending on export_state (in proto_want_export_up() and
 * proto_want_export_down()) and they are automatically freed after the protocol
 * is flushed (in proto_fell_down()).
163
 *
164 165 166 167
 * 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.
168
 */
169
struct announce_hook *
170
proto_add_announce_hook(struct proto *p, struct rtable *t, struct proto_stats *stats)
171 172 173 174
{
  struct announce_hook *h;

  DBG("Connecting protocol %s to table %s\n", p->name, t->name);
175
  PD(p, "Connected to table %s", t->name);
176 177

  h = mb_allocz(rt_table_pool, sizeof(struct announce_hook));
178 179
  h->table = t;
  h->proto = p;
180 181
  h->stats = stats;

182 183
  h->next = p->ahooks;
  p->ahooks = h;
184

185
  if (p->rt_notify && (p->export_state != ES_DOWN))
186
    add_tail(&t->hooks, &h->n);
187 188 189
  return h;
}

190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
/**
 * proto_find_announce_hook - find announce hooks
 * @p: protocol instance
 * @t: routing table
 *
 * Returns pointer to announce hook or NULL
 */
struct announce_hook *
proto_find_announce_hook(struct proto *p, struct rtable *t)
{
  struct announce_hook *a;

  for (a = p->ahooks; a; a = a->next)
    if (a->table == t)
      return a;

  return NULL;
}

209 210 211 212 213 214 215 216 217 218
static void
proto_link_ahooks(struct proto *p)
{
  struct announce_hook *h;

  if (p->rt_notify)
    for(h=p->ahooks; h; h=h->next)
      add_tail(&h->table->hooks, &h->n);
}

219
static void
220
proto_unlink_ahooks(struct proto *p)
221 222 223
{
  struct announce_hook *h;

224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
  if (p->rt_notify)
    for(h=p->ahooks; h; h=h->next)
      rem_node(&h->n);
}

static void
proto_free_ahooks(struct proto *p)
{
  struct announce_hook *h, *hn;

  for(h = p->ahooks; h; h = hn)
  {
    hn = h->next;
    mb_free(h);
  }

240
  p->ahooks = NULL;
241
  p->main_ahook = NULL;
242 243
}

244

245 246 247 248
/**
 * proto_config_new - create a new protocol configuration
 * @pr: protocol the configuration will belong to
 * @size: size of the structure including generic data
249
 * @class: SYM_PROTO or SYM_TEMPLATE
250 251 252 253 254 255 256 257
 *
 * 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.
258 259 260 261 262
 *
 * The function is also used to create protocol templates (when class
 * SYM_TEMPLATE is specified), the only difference is that templates
 * are not added to the list of protocol instances and therefore not
 * initialized during protos_commit()).
263
 */
264
void *
265
proto_config_new(struct protocol *pr, unsigned size, int class)
266 267 268
{
  struct proto_config *c = cfg_allocz(size);

269 270
  if (class == SYM_PROTO)
    add_tail(&new_config->protos, &c->n);
271
  c->global = new_config;
272
  c->protocol = pr;
273
  c->name = pr->name;
274
  c->preference = pr->preference;
275
  c->class = class;
276
  c->out_filter = FILTER_REJECT;
277
  c->table = c->global->master_rtc;
278
  c->debug = new_config->proto_default_debug;
279
  c->mrtdump = new_config->proto_default_mrtdump;
280 281 282
  return c;
}

283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
/**
 * proto_copy_config - copy a protocol configuration
 * @dest: destination protocol configuration
 * @src: source protocol configuration
 *
 * Whenever a new instance of a routing protocol is created from the
 * template, proto_copy_config() is called to copy a content of
 * the source protocol configuration to the new protocol configuration.
 * Name, class and a node in protos list of @dest are kept intact.
 * copy_config() protocol hook is used to copy protocol-specific data.
 */
void
proto_copy_config(struct proto_config *dest, struct proto_config *src)
{
  node old_node;
  int old_class;
  char *old_name;

  if (dest->protocol != src->protocol)
    cf_error("Can't copy configuration from a different protocol type");

  if (dest->protocol->copy_config == NULL)
    cf_error("Inheriting configuration for %s is not supported", src->protocol->name);

  DBG("Copying configuration from %s to %s\n", src->name, dest->name);

  /* 
   * Copy struct proto_config here. Keep original node, class and name.
   * protocol-specific config copy is handled by protocol copy_config() hook
   */

  old_node = dest->n;
  old_class = dest->class;
  old_name = dest->name;

  memcpy(dest, src, sizeof(struct proto_config));

  dest->n = old_node;
  dest->class = old_class;
  dest->name = old_name;

  dest->protocol->copy_config(dest, src);
}

327 328 329 330 331 332 333 334
/**
 * 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.
 */
335
void
336
protos_preconfig(struct config *c)
337
{
338 339
  struct protocol *p;

340
  init_list(&c->protos);
341
  DBG("Protocol preconfig:");
342 343
  WALK_LIST(p, protocol_list)
    {
344
      DBG(" %s", p->name);
345
      p->name_counter = 0;
346
      if (p->preconfig)
347
	p->preconfig(p, c);
348
    }
349
  DBG("\n");
350 351
}

352 353 354 355 356
/**
 * protos_postconfig - post-configuration processing
 * @c: new configuration
 *
 * This function calls the postconfig() hooks of all protocol
357 358
 * instances specified in configuration @c. The hooks are not
 * called for protocol templates.
359
 */
360
void
361
protos_postconfig(struct config *c)
362
{
363
  struct proto_config *x;
364 365
  struct protocol *p;

366
  DBG("Protocol postconfig:");
367
  WALK_LIST(x, c->protos)
368
    {
369
      DBG(" %s", x->name);
370

371
      p = x->protocol;
372
      if (p->postconfig)
373 374
	p->postconfig(x);
    }
375
  DBG("\n");
376 377
}

378 379
extern struct protocol proto_unix_iface;

380 381 382 383 384 385 386 387
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;
388
  q->export_state = ES_DOWN;
389 390
  q->last_state_change = now;

391 392
  add_tail(&initial_proto_list, &q->n);

393 394 395
  if (p == &proto_unix_iface)
    initial_device_proto = q;

396
  add_tail(&proto_list, &q->glob_node);
Martin Mareš's avatar
Martin Mareš committed
397
  PD(q, "Initializing%s", q->disabled ? " [disabled]" : "");
398 399 400
  return q;
}

401 402
int proto_reconfig_type;  /* Hack to propagate type info to pipe reconfigure hook */

403 404 405
static int
proto_reconfigure(struct proto *p, struct proto_config *oc, struct proto_config *nc, int type)
{
406
  struct announce_hook *ah = p->main_ahook;
407 408 409 410 411 412
  /* If the protocol is DOWN, we just restart it */
  if (p->proto_state == PS_DOWN)
    return 0;

  /* If there is a too big change in core attributes, ... */
  if ((nc->protocol != oc->protocol) ||
413
      (nc->disabled != p->disabled) ||
414
      (nc->table->table != oc->table->table))
415 416 417 418
    return 0;

  p->debug = nc->debug;
  p->mrtdump = nc->mrtdump;
419
  proto_reconfig_type = type;
420 421 422 423 424 425 426 427 428

  /* Execute protocol specific reconfigure hook */
  if (! (p->proto->reconfigure && p->proto->reconfigure(p, nc)))
    return 0;

  DBG("\t%s: same\n", oc->name);
  PD(p, "Reconfigured");
  p->cf = nc;
  p->name = nc->name;
429
  p->preference = nc->preference;
430

431 432 433 434 435

  /* Multitable protocols handle rest in their reconfigure hooks */
  if (p->proto->multitable)
    return 1;

436 437
  /* Update filters and limits in the main announce hook
     Note that this also resets limit state */
438
  if (ah)
439
    {
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
      ah->in_filter = nc->in_filter;
      ah->out_filter = nc->out_filter;
      ah->rx_limit = nc->rx_limit;
      ah->in_limit = nc->in_limit;
      ah->out_limit = nc->out_limit;
      ah->in_keep_filtered = nc->in_keep_filtered;

      if (p->proto_state == PS_UP)	/* Recheck export/import/receive limit */
        {
          struct proto_stats *stats = ah->stats;
          struct proto_limit *l = ah->in_limit;
          u32 all_routes = stats->imp_routes + stats->filt_routes;

          if (l && (stats->imp_routes >= l->limit)) proto_notify_limit(ah, l, PLD_IN, stats->imp_routes);

          l = ah->rx_limit;

          if (l && ( all_routes >= l->limit)) proto_notify_limit(ah, l, PLD_RX, all_routes );

          l = ah->out_limit;

          if (l && ( stats->exp_routes >= l->limit)) proto_notify_limit(ah, l, PLD_OUT, stats->exp_routes);
        }
463 464 465 466 467 468 469 470 471 472 473 474 475 476
    }

  /* Update routes when filters changed. If the protocol in not UP,
     it has no routes and we can ignore such changes */
  if ((p->proto_state != PS_UP) || (type == RECONFIG_SOFT))
    return 1;

  int import_changed = ! filter_same(nc->in_filter, oc->in_filter);
  int export_changed = ! filter_same(nc->out_filter, oc->out_filter);

  /* We treat a change in preferences by reimporting routes */
  if (nc->preference != oc->preference)
    import_changed = 1;

477 478 479
  if (import_changed || export_changed)
    log(L_INFO "Reloading protocol %s", p->name);

480 481
  /* If import filter changed, call reload hook */
  if (import_changed && ! (p->reload_routes && p->reload_routes(p)))
482 483 484
    {
      /* Now, the protocol is reconfigured. But route reload failed
	 and we have to do regular protocol restart. */
485
      log(L_INFO "Restarting protocol %s", p->name);
486
      p->disabled = 1;
487
      p->down_code = PDC_CF_RESTART;
488 489 490 491 492 493 494 495 496 497 498 499
      proto_rethink_goal(p);
      p->disabled = 0;
      proto_rethink_goal(p);
      return 1;
    }

  if (export_changed)
    proto_request_feeding(p);

  return 1;
}

500 501 502 503 504 505
/**
 * 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)
506
 * @type: type of reconfiguration (RECONFIG_SOFT or RECONFIG_HARD)
507 508 509 510 511 512 513 514 515 516 517 518
 *
 * 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.
 *
519 520 521 522 523 524 525 526
 * 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 (changes in filters are ignored
 * if type is RECONFIG_SOFT) 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.
527
 */
528
void
529
protos_commit(struct config *new, struct config *old, int force_reconfig, int type)
530
{
531 532
  struct proto_config *oc, *nc;
  struct proto *p, *n;
533
  struct symbol *sym;
534

535 536
  DBG("protos_commit:\n");
  if (old)
537
    {
538 539
      WALK_LIST(oc, old->protos)
	{
540 541
	  p = oc->proto;
	  sym = cf_find_symbol(oc->name);
542
	  if (sym && sym->class == SYM_PROTO && !new->shutdown)
543 544
	    {
	      /* Found match, let's check if we can smoothly switch to new configuration */
545
	      /* No need to check description */
546
	      nc = sym->def;
547 548 549 550 551 552 553
	      nc->proto = p;

	      /* We will try to reconfigure protocol p */
	      if (! force_reconfig && proto_reconfigure(p, oc, nc, type))
		continue;

	      /* Unsuccessful, we will restart it */
554 555 556 557 558 559 560
	      if (!p->disabled && !nc->disabled)
		log(L_INFO "Restarting protocol %s", p->name);
	      else if (p->disabled && !nc->disabled)
		log(L_INFO "Enabling protocol %s", p->name);
	      else if (!p->disabled && nc->disabled)
		log(L_INFO "Disabling protocol %s", p->name);

561
	      p->down_code = nc->disabled ? PDC_CF_DISABLE : PDC_CF_RESTART;
562 563
	      p->cf_new = nc;
	    }
564
	  else if (!new->shutdown)
565
	    {
566
	      log(L_INFO "Removing protocol %s", p->name);
567
	      p->down_code = PDC_CF_REMOVE;
568 569
	      p->cf_new = NULL;
	    }
570 571 572 573 574
	  else /* global shutdown */
	    {
	      p->down_code = PDC_CMD_SHUTDOWN;
	      p->cf_new = NULL;
	    }
575

576
	  p->reconfiguring = 1;
577 578 579
	  config_add_obstacle(old);
	  proto_rethink_goal(p);
	}
580
    }
581 582 583 584

  WALK_LIST(nc, new->protos)
    if (!nc->proto)
      {
585
	if (old)		/* Not a first-time configuration */
586
	  log(L_INFO "Adding protocol %s", nc->name);
587 588 589 590 591
	proto_init(nc);
      }
  DBG("\tdone\n");

  DBG("Protocol start\n");
592 593 594 595 596 597 598 599

  /* Start device protocol first */
  if (initial_device_proto)
  {
    proto_rethink_goal(initial_device_proto);
    initial_device_proto = NULL;
  }

600 601 602 603 604 605 606 607 608 609
  /* Determine router ID for the first time - it has to be here and not in
     global_commit() because it is postponed after start of device protocol */
  if (!config->router_id)
    {
      config->router_id = if_choose_router_id(config->router_id_from, 0);
      if (!config->router_id)
	die("Cannot determine router ID, please configure it manually");
    }

  /* Start all other protocols */
610 611
  WALK_LIST_DELSAFE(p, n, initial_proto_list)
    proto_rethink_goal(p);
612 613
}

614
static void
615
proto_rethink_goal(struct proto *p)
616
{
617
  struct protocol *q;
618
  byte goal;
619 620 621 622 623 624 625

  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);
626
      rem_node(&p->glob_node);
627 628 629
      mb_free(p);
      if (!nc)
	return;
630
      p = proto_init(nc);
631 632 633
    }

  /* Determine what state we want to reach */
634
  if (p->disabled || p->reconfiguring)
635
    goal = PS_DOWN;
636
  else
637
    goal = PS_UP;
638 639

  q = p->proto;
640
  if (goal == PS_UP) 			/* Going up */
641
    {
642
      if (p->proto_state == PS_DOWN && p->core_state == FS_HUNGRY)
643 644
	{
	  DBG("Kicking %s up\n", p->name);
645
	  PD(p, "Starting");
646
	  proto_init_instance(p);
647 648 649 650 651 652 653 654
	  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);
655
	  PD(p, "Shutting down");
656 657 658 659 660
	  proto_notify_state(p, (q->shutdown ? q->shutdown(p) : PS_DOWN));
	}
    }
}

661

662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691
/**
 * DOC: Graceful restart recovery
 *
 * Graceful restart of a router is a process when the routing plane (e.g. BIRD)
 * restarts but both the forwarding plane (e.g kernel routing table) and routing
 * neighbors keep proper routes, and therefore uninterrupted packet forwarding
 * is maintained.
 *
 * BIRD implements graceful restart recovery by deferring export of routes to
 * protocols until routing tables are refilled with the expected content. After
 * start, protocols generate routes as usual, but routes are not propagated to
 * them, until protocols report that they generated all routes. After that,
 * graceful restart recovery is finished and the export (and the initial feed)
 * to protocols is enabled.
 *
 * When graceful restart recovery need is detected during initialization, then
 * enabled protocols are marked with @gr_recovery flag before start. Such
 * protocols then decide how to proceed with graceful restart, participation is
 * voluntary. Protocols could lock the recovery by proto_graceful_restart_lock()
 * (stored in @gr_lock flag), which means that they want to postpone the end of
 * the recovery until they converge and then unlock it. They also could set
 * @gr_wait before advancing to %PS_UP, which means that the core should defer
 * route export to that protocol until the end of the recovery. This should be
 * done by protocols that expect their neigbors to keep the proper routes
 * (kernel table, BGP sessions with BGP graceful restart capability).
 *
 * The graceful restart recovery is finished when either all graceful restart
 * locks are unlocked or when graceful restart wait timer fires.
 *
 */
692

693
static void graceful_restart_done(struct timer *t);
694

695 696 697 698 699 700 701
/**
 * graceful_restart_recovery - request initial graceful restart recovery
 *
 * Called by the platform initialization code if the need for recovery
 * after graceful restart is detected during boot. Have to be called
 * before protos_commit().
 */
702 703 704 705 706 707
void
graceful_restart_recovery(void)
{
  graceful_restart_state = GRS_INIT;
}

708 709 710 711 712 713 714
/**
 * graceful_restart_init - initialize graceful restart
 *
 * When graceful restart recovery was requested, the function starts an active
 * phase of the recovery and initializes graceful restart wait timer. The
 * function have to be called after protos_commit().
 */
715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734
void
graceful_restart_init(void)
{
  if (!graceful_restart_state)
    return;

  log(L_INFO "Graceful restart started");

  if (!graceful_restart_locks)
    {
      graceful_restart_done(NULL);
      return;
    }

  graceful_restart_state = GRS_ACTIVE;
  gr_wait_timer = tm_new(proto_pool);
  gr_wait_timer->hook = graceful_restart_done;
  tm_start(gr_wait_timer, config->gr_wait);
}

735 736 737 738 739 740 741 742 743
/**
 * graceful_restart_done - finalize graceful restart
 *
 * When there are no locks on graceful restart, the functions finalizes the
 * graceful restart recovery. Protocols postponing route export until the end of
 * the recovery are awakened and the export to them is enabled. All other
 * related state is cleared. The function is also called when the graceful
 * restart wait timer fires (but there are still some locks).
 */
744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
static void
graceful_restart_done(struct timer *t UNUSED)
{
  struct proto *p;
  node *n;

  log(L_INFO "Graceful restart done");
  graceful_restart_state = GRS_DONE;

  WALK_LIST2(p, n, proto_list, glob_node)
    {
      if (!p->gr_recovery)
	continue;

      /* Resume postponed export of routes */
      if ((p->proto_state == PS_UP) && p->gr_wait)
760
      {
761
	proto_want_export_up(p);
762 763
	proto_log_state_change(p);
      }
764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784

      /* Cleanup */
      p->gr_recovery = 0;
      p->gr_wait = 0;
      p->gr_lock = 0;
    }

  graceful_restart_locks = 0;
}

void
graceful_restart_show_status(void)
{
  if (graceful_restart_state != GRS_ACTIVE)
    return;

  cli_msg(-24, "Graceful restart recovery in progress");
  cli_msg(-24, "  Waiting for %d protocols to recover", graceful_restart_locks);
  cli_msg(-24, "  Wait timer is %d/%d", tm_remains(gr_wait_timer), config->gr_wait);
}

785 786 787 788 789 790 791 792 793 794 795 796 797
/**
 * proto_graceful_restart_lock - lock graceful restart by protocol
 * @p: protocol instance
 *
 * This function allows a protocol to postpone the end of graceful restart
 * recovery until it converges. The lock is removed when the protocol calls
 * proto_graceful_restart_unlock() or when the protocol is stopped.
 *
 * The function have to be called during the initial phase of graceful restart
 * recovery and only for protocols that are part of graceful restart (i.e. their
 * @gr_recovery is set), which means it should be called from protocol start
 * hooks.
 */
798 799 800 801 802 803 804 805 806 807 808 809 810
void
proto_graceful_restart_lock(struct proto *p)
{
  ASSERT(graceful_restart_state == GRS_INIT);
  ASSERT(p->gr_recovery);

  if (p->gr_lock)
    return;

  p->gr_lock = 1;
  graceful_restart_locks++;
}

811 812 813 814 815 816 817
/**
 * proto_graceful_restart_unlock - unlock graceful restart by protocol
 * @p: protocol instance
 *
 * This function unlocks a lock from proto_graceful_restart_lock(). It is also
 * automatically called when the lock holding protocol went down.
 */
818 819 820 821 822 823 824 825 826 827 828 829 830 831 832
void
proto_graceful_restart_unlock(struct proto *p)
{
  if (!p->gr_lock)
    return;

  p->gr_lock = 0;
  graceful_restart_locks--;

  if ((graceful_restart_state == GRS_ACTIVE) && !graceful_restart_locks)
    tm_start(gr_wait_timer, 0);
}



833 834 835 836 837 838 839 840 841
/**
 * 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.
 */
842 843 844 845
void
protos_dump_all(void)
{
  struct proto *p;
846
  struct announce_hook *a;
847 848 849

  debug("Protocols:\n");

850
  WALK_LIST(p, active_proto_list)
851
    {
852
      debug("  protocol %s state %s/%s\n", p->name,
853
	    p_states[p->proto_state], c_states[p->core_state]);
854 855 856 857 858 859 860 861
      for (a = p->ahooks; a; a = a->next)
	{
	  debug("\tTABLE %s\n", a->table->name);
	  if (a->in_filter)
	    debug("\tInput filter: %s\n", filter_name(a->in_filter));
	  if (a->out_filter != FILTER_REJECT)
	    debug("\tOutput filter: %s\n", filter_name(a->out_filter));
	}
862 863
      if (p->disabled)
	debug("\tDISABLED\n");
864 865
      else if (p->proto->dump)
	p->proto->dump(p);
866
    }
867
  WALK_LIST(p, inactive_proto_list)
868 869 870
    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);
871 872
  WALK_LIST(p, flush_proto_list)
    debug("  flushing %s\n", p->name);
873 874
}

875 876 877 878 879 880
/**
 * 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
881
 * all platform specific protocols to inform the core that they exist.
882
 */
883 884 885 886 887 888 889 890 891 892 893
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;
    }
}

894 895 896
/* FIXME: convert this call to some protocol hook */
extern void bfd_init_all(void);

897 898 899 900 901 902 903 904 905
/**
 * 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.
 */
906 907 908 909
void
protos_build(void)
{
  init_list(&protocol_list);
910 911 912 913 914
  init_list(&proto_list);
  init_list(&active_proto_list);
  init_list(&inactive_proto_list);
  init_list(&initial_proto_list);
  init_list(&flush_proto_list);
915
  proto_build(&proto_device);
916 917 918
#ifdef CONFIG_RADV
  proto_build(&proto_radv);
#endif
919
#ifdef CONFIG_RIP
920
  proto_build(&proto_rip);
921 922
#endif
#ifdef CONFIG_STATIC
923
  proto_build(&proto_static);
Ondřej Filip's avatar
Ondřej Filip committed
924 925
#endif
#ifdef CONFIG_OSPF
926
  proto_build(&proto_ospf);
927 928
#endif
#ifdef CONFIG_PIPE
929
  proto_build(&proto_pipe);
930 931
#endif
#ifdef CONFIG_BGP
932
  proto_build(&proto_bgp);
933
#endif
934
#ifdef CONFIG_BFD
935
  proto_build(&proto_bfd);
936 937
  bfd_init_all();
#endif
938

939
  proto_pool = rp_new(&root_pool, "Protocols");
940
  proto_flush_event = ev_new(proto_pool);
941
  proto_flush_event->hook = proto_flush_loop;
942 943
  proto_shutdown_timer = tm_new(proto_pool);
  proto_shutdown_timer->hook = proto_shutdown_loop;
944 945
}

946 947 948 949 950
static void
proto_feed_more(void *P)
{
  struct proto *p = P;

951
  if (p->export_state != ES_FEEDING)
952
    return;
953 954

  DBG("Feeding protocol %s continued\n", p->name);
955 956
  if (rt_feed_baby(p))
    {
957 958
      DBG("Feeding protocol %s finished\n", p->name);
      p->export_state = ES_READY;
959
      proto_log_state_change(p);
960 961 962

      if (p->feed_done)
	p->feed_done(p);
963 964 965 966 967 968 969 970
    }
  else
    {
      p->attn->hook = proto_feed_more;
      ev_schedule(p->attn);		/* Will continue later... */
    }
}

971
static void
972
proto_feed_initial(void *P)
973 974 975
{
  struct proto *p = P;

976
  if (p->export_state != ES_FEEDING)
977 978
    return;

979
  DBG("Feeding protocol %s\n", p->name);
980

981
  if_feed_baby(p);
982
  proto_feed_more(P);
983 984
}

985
static void
986
proto_schedule_feed(struct proto *p, int initial)
987 988
{
  DBG("%s: Scheduling meal\n", p->name);
989

990 991
  p->export_state = ES_FEEDING;
  p->refeeding = !initial;
992

993
  p->attn->hook = initial ? proto_feed_initial : proto_feed_more;
994 995 996
  ev_schedule(p->attn);
}

997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
/*
 * Flushing loop is responsible for flushing routes and protocols
 * after they went down. It runs in proto_flush_event. At the start of
 * one round, protocols waiting to flush are marked in
 * proto_schedule_flush_loop(). At the end of the round (when routing
 * table flush is complete), marked protocols are flushed and a next
 * round may start.
 */

static int flush_loop_state;	/* 1 -> running */

static void
proto_schedule_flush_loop(void)
{
  struct proto *p;
1012
  struct announce_hook *h;
1013 1014 1015 1016 1017 1018

  if (flush_loop_state)
    return;
  flush_loop_state = 1;

  WALK_LIST(p, flush_proto_list)
1019
  {
1020
    p->flushing = 1;
1021
    for (h=p->ahooks; h; h=h->next)
1022
      rt_mark_for_prune(h->table);
1023
  }
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039

  ev_schedule(proto_flush_event);
}

static void
proto_flush_loop(void *unused UNUSED)
{
  struct proto *p;

  if (! rt_prune_loop())
    {
      /* Rtable pruning is not finished */
      ev_schedule(proto_flush_event);
      return;
    }

1040 1041
  rt_prune_sources();

1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
 again:
  WALK_LIST(p, flush_proto_list)
    if (p->flushing)
      {
	/* This will flush interfaces in the same manner
	   like rt_prune_all() flushes routes */
	if (p->proto == &proto_unix_iface)
	  if_flush_ifaces(p);

	DBG("Flushing protocol %s\n", p->name);
	p->flushing = 0;
1053 1054 1055
	p->core_state = FS_HUNGRY;
	proto_relink(p);
	proto_log_state_change(p);
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
	if (p->proto_state == PS_DOWN)
	  proto_fell_down(p);
	goto again;
      }

  /* This round finished, perhaps there will be another one */
  flush_loop_state = 0;
  if (!EMPTY_LIST(flush_proto_list))
    proto_schedule_flush_loop();
}


1068 1069
/* Temporary hack to propagate restart to BGP */
int proto_restart;
1070

1071 1072 1073 1074 1075 1076 1077 1078
static void
proto_shutdown_loop(struct timer *t UNUSED)
{
  struct proto *p, *p_next;

  WALK_LIST_DELSAFE(p, p_next, active_proto_list)
    if (p->down_sched)
      {
1079
	proto_restart = (p->down_sched == PDS_RESTART);
1080 1081 1082

	p->disabled = 1;
	proto_rethink_goal(p);
1083
	if (proto_restart)
1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
	  {
	    p->disabled = 0;
	    proto_rethink_goal(p);
	  }
      }
}

static inline void
proto_schedule_down(struct proto *p, byte restart, byte code)
{
  /* Does not work for other states (even PS_START) */
  ASSERT(p->proto_state == PS_UP);

  /* Scheduled restart may change to shutdown, but not otherwise */
  if (p->down_sched == PDS_DISABLE)
    return;

  p->down_sched = restart ? PDS_RESTART : PDS_DISABLE;
  p->down_code = code;
  tm_start_max(proto_shutdown_timer, restart ? 2 : 0);
}


1107 1108 1109 1110 1111 1112
/**
 * proto_request_feeding - request feeding routes to the protocol
 * @p: given protocol 
 *
 * Sometimes it is needed to send again all routes to the
 * protocol. This is called feeding and can be requested by this
1113 1114 1115
 * function. This would cause protocol export state transition
 * to ES_FEEDING (during feeding) and when completed, it will
 * switch back to ES_READY. This function can be called even
1116 1117 1118 1119 1120 1121 1122
 * when feeding is already running, in that case it is restarted.
 */
void
proto_request_feeding(struct proto *p)
{
  ASSERT(p->proto_state == PS_UP);

1123 1124 1125 1126
  /* Do nothing if we are still waiting for feeding */
  if (p->export_state == ES_DOWN)
    return;

1127
  /* If we are already feeding, we want to restart it */
1128
  if (p->export_state == ES_FEEDING)
1129 1130 1131 1132 1133 1134 1135 1136
    {
      /* Unless feeding is in initial state */
      if (p->attn->hook == proto_feed_initial)
	return;

      rt_feed_baby_abort(p);
    }

1137 1138 1139 1140 1141 1142 1143 1144
  /* FIXME: This should be changed for better support of multitable protos */
  struct announce_hook *ah;
  for (ah = p->ahooks; ah; ah = ah->next)
    proto_reset_limit(ah->out_limit);

  /* Hack: reset exp_routes during refeed, and do not decrease it later */
  p->stats.exp_routes = 0;

1145
  proto_schedule_feed(p, 0);
1146
  proto_log_state_change(p);
1147 1148
}

1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165
static const char *
proto_limit_name(struct proto_limit *l)
{
  const char *actions[] = {
    [PLA_WARN] = "warn",
    [PLA_BLOCK] = "block",
    [PLA_RESTART] = "restart",
    [PLA_DISABLE] = "disable",
  };

  return actions[l->action];
}

/**
 * proto_notify_limit: notify about limit hit and take appropriate action
 * @ah: announce hook
 * @l: limit being hit
1166
 * @dir: limit direction (PLD_*)
1167
 * @rt_count: the number of routes 
1168 1169 1170
 *
 * The function is called by the route processing core when limit @l
 * is breached. It activates the limit and tooks appropriate action
1171
 * according to @l->action.
1172
 */
1173
void
1174
proto_notify_limit(struct announce_hook *ah, struct proto_limit *l, int dir, u32 rt_count)
1175
{
1176 1177
  const char *dir_name[PLD_MAX] = { "receive", "import" , "export" };
  const byte dir_down[PLD_MAX] = { PDC_RX_LIMIT_HIT, PDC_IN_LIMIT_HIT, PDC_OUT_LIMIT_HIT };
1178 1179
  struct proto *p = ah->proto;

1180 1181
  if (l->state == PLS_BLOCKED)
    return;
1182

1183 1184
  /* For warning action, we want the log message every time we hit the limit */
  if (!l->state || ((l->action == PLA_WARN) && (rt_count == l->limit)))
1185
    log(L_WARN "Protocol %s hits route %s limit (%d), action: %s",
1186
	p->name, dir_name[dir], l->limit, proto_limit_name(l));
1187 1188 1189 1190

  switch (l->action)
    {
    case PLA_WARN:
1191 1192
      l->state = PLS_ACTIVE;
      break;
1193 1194

    case PLA_BLOCK:
1195 1196
      l->state = PLS_BLOCKED;
      break;
1197 1198 1199

    case PLA_RESTART:
    case PLA_DISABLE:
1200
      l->state = PLS_BLOCKED;
1201
      proto_schedule_down(p, l->action == PLA_RESTART, dir_down[dir]);
1202
      break;
1203 1204 1205
    }
}

1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230

static void
proto_want_core_up(struct proto *p)
{
  ASSERT(p->core_state == FS_HUNGRY);

  if (!p->proto->multitable)
    {
      p->main_source = rt_get_source(p, 0);
      rt_lock_source(p->main_source);

      /* Connect protocol to routing table */
      p->main_ahook = proto_add_announce_hook(p, p->table, &p->stats);
      p->main_ahook->in_filter = p->cf->in_filter;
      p->main_ahook->out_filter = p->cf->out_filter;
      p->main_ahook->rx_limit = p->cf->rx_limit;
      p->main_ahook->in_limit = p->cf->in_limit;
      p->main_ahook->out_limit = p->cf->out_limit;
      p->main_ahook->in_keep_filtered = p->cf->in_keep_filtered;

      proto_reset_limit(p->main_ahook->rx_limit);
      proto_reset_limit(p->main_ahook->in_limit);
      proto_reset_limit(p->main_ahook->out_limit);
    }

1231 1232
  p->core_state = FS_HAPPY;
  proto_relink(p);
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
}

static void
proto_want_export_up(struct proto *p)
{
  ASSERT(p->core_state == CS_HAPPY);
  ASSERT(p->export_state == ES_DOWN);

  proto_link_ahooks(p);
  proto_schedule_feed(p, 1); /* Sets ES_FEEDING */
}

static void
proto_want_export_down(struct proto *p)
{
  ASSERT(p->export_state != ES_DOWN);

  /* Need to abort feeding */
  if (p->export_state == ES_FEEDING)
    rt_feed_baby_abort(p);

  p->export_state = ES_DOWN;
  proto_unlink_ahooks(p);
}

static void
proto_want_core_down(struct proto *p)
{
  ASSERT(p->core_state == CS_HAPPY);
  ASSERT(p->export_state == ES_DOWN);

1264 1265
  p->core_state = FS_FLUSHING;
  proto_relink(p);
1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
  proto_schedule_flush_loop();

  if (!p->proto->multitable)
    {
      rt_unlock_source(p->main_source);
      p->main_source = NULL;
    }
}

static void
proto_falling_down(struct proto *p)
{
  p->gr_recovery = 0;
  p->gr_wait = 0;
  if (p->gr_lock)
    proto_graceful_restart_unlock(p);
}

1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304
static void
proto_fell_down(struct proto *p)
{
  DBG("Protocol %s down\n", p->name);

  u32 all_routes = p->stats.imp_routes + p->stats.filt_routes;
  if (all_routes != 0)
    log(L_ERR "Protocol %s is down but still has %d routes", p->name, all_routes);

  bzero(&p->stats, sizeof(struct proto_stats));
  proto_free_ahooks(p);

  if (! p->proto->multitable)
    rt_unlock_table(p->table);

  if (p->proto->cleanup)
    p->proto->cleanup(p);

  proto_rethink_goal(p);
}

1305

1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
/**
 * 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
1316 1317 1318
 * state. State change to PS_DOWN immediately frees resources of protocol
 * and might execute start callback of protocol; therefore,
 * it should be used at tail positions of protocol callbacks.
1319
 */
1320 1321 1322 1323 1324
void
proto_notify_state(struct proto *p, unsigned ps)
{
  unsigned ops = p->proto_state;
  unsigned cs = p->core_state;
1325
  unsigned es = p->export_state;
1326 1327 1328 1329 1330

  DBG("%s reporting state transition %s/%s -> */%s\n", p->name, c_states[cs], p_states[ops], p_states[ps]);
  if (ops == ps)
    return;

1331
  p->proto_state = ps;
1332
  p->last_state_change = now;
1333

1334 1335
  switch (ps)
    {
1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366
    case PS_START:
      ASSERT(ops == PS_DOWN || ops == PS_UP);
      ASSERT(cs == FS_HUNGRY || cs == FS_HAPPY);

      if (es != ES_DOWN)
	proto_want_export_down(p);
      break;

    case PS_UP:
      ASSERT(ops == PS_DOWN || ops == PS_START);
      ASSERT(cs == FS_HUNGRY || cs == FS_HAPPY);
      ASSERT(es == ES_DOWN);

      if (cs == FS_HUNGRY)
	proto_want_core_up(p);
      if (!p->gr_wait)
	proto_want_export_up(p);
      break;

    case PS_STOP:
      ASSERT(ops == PS_START || ops == PS_UP);

      p->down_sched = 0;

      if (es != ES_DOWN)
	proto_want_export_down(p);
      if (cs == FS_HAPPY)
	proto_want_core_down(p);
      proto_falling_down(p);
      break;

1367
    case PS_DOWN:
1368 1369
      p->down_code = 0;
      p->down_sched = 0;
1370

1371 1372 1373 1374 1375 1376
      if (es != ES_DOWN)
	proto_want_export_down(p);
      if (cs == FS_HAPPY)
	proto_want_core_down(p);
      if (ops != PS_STOP)
	proto_falling_down(p);
1377

1378 1379 1380 1381
      neigh_prune(); // FIXME convert neighbors to resource?
      rfree(p->pool);
      p->pool = NULL;

1382
      if (cs == FS_HUNGRY)		/* Shutdown finished */
1383
	{
1384
	  proto_log_state_change(p);
1385 1386 1387
	  proto_fell_down(p);
	  return;			/* The protocol might have ceased to exist */
	}
1388
      break;
1389

1390
    default:
1391
      bug("%s: Invalid state %d", p->name, ps);
1392
    }
1393 1394

  proto_log_state_change(p);
1395
}
1396

1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407
/*
 *  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";
1408 1409 1410 1411 1412 1413 1414 1415 1416 1417
    case P(PS_START, FS_HUNGRY):
    case P(PS_START, FS_HAPPY):		return "start";
    case P(PS_UP, FS_HAPPY):
      switch (p->export_state)
	{
	case ES_DOWN:			return "wait";
	case ES_FEEDING:		return "feed";
	case ES_READY:			return "up";
	default:      			return "???";
	}
1418 1419
    case P(PS_STOP, FS_HUNGRY):
    case P(PS_STOP, FS_FLUSHING):	return "stop";
1420 1421 1422 1423 1424 1425
    case P(PS_DOWN, FS_FLUSHING):	return "flush";
    default:      			return "???";
    }
#undef P
}

1426
static void
1427
proto_show_stats(struct proto_stats *s, int in_keep_filtered)
1428
{
1429 1430 1431
  if (in_keep_filtered)
    cli_msg(-1006, "  Routes:         %u imported, %u filtered, %u exported, %u preferred", 
	    s->imp_routes, s->filt_routes, s->exp_routes, s->pref_routes);
1432 1433 1434 1435
  else
    cli_msg(-1006, "  Routes:         %u imported, %u exported, %u preferred", 
	    s->imp_routes, s->exp_routes, s->pref_routes);

1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450
  cli_msg(-1006, "  Route change stats:     received   rejected   filtered    ignored   accepted");
  cli_msg(-1006, "    Import updates:     %10u %10u %10u %10u %10u",
	  s->imp_updates_received, s->imp_updates_invalid,
	  s->imp_updates_filtered, s->imp_updates_ignored,
	  s->imp_updates_accepted);
  cli_msg(-1006, "    Import withdraws:   %10u %10u        --- %10u %10u",
	  s->imp_withdraws_received, s->imp_withdraws_invalid,
	  s->imp_withdraws_ignored, s->imp_withdraws_accepted);
  cli_msg(-1006, "    Export updates:     %10u %10u %10u        --- %10u",
	  s->exp_updates_received, s->exp_updates_rejected,
	  s->exp_updates_filtered, s->exp_updates_accepted);
  cli_msg(-1006, "    Export withdraws:   %10u        ---        ---        --- %10u",
	  s->exp_withdraws_received, s->exp_withdraws_accepted);
}

1451 1452 1453
void
proto_show_limit(struct proto_limit *l, const char *dsc)
{
1454 1455 1456 1457 1458
  if (!l)
    return;

  cli_msg(-1006, "  %-16s%d%s", dsc, l->limit, l->state ? " [HIT]" : "");
  cli_msg(-1006, "    Action:       %s", proto_limit_name(l));
1459 1460
}

1461 1462
void
proto_show_basic_info(struct proto *p)
1463
{
1464 1465 1466 1467
  // cli_msg(-1006, "  Table:          %s", p->table->name);
  cli_msg(-1006, "  Preference:     %d", p->preference);
  cli_msg(-1006, "  Input filter:   %s", filter_name(p->cf->in_filter));
  cli_msg(-1006, "  Output filter:  %s", filter_name(p->cf->out_filter));
1468

1469 1470 1471 1472 1473
  if (graceful_restart_state == GRS_ACTIVE)
    cli_msg(-1006, "  GR recovery:   %s%s",
	    p->gr_lock ? " pending" : "",
	    p->gr_wait ? " waiting" : "");

1474
  proto_show_limit(p->cf->rx_limit, "Receive limit:");
1475
  proto_show_limit(p->cf->in_limit, "Import limit:");
1476
  proto_show_limit(p->cf->out_limit, "Export limit:");
1477

1478
  if (p->proto_state != PS_DOWN)
1479
    proto_show_stats(&p->stats, p->cf->in_keep_filtered);
1480 1481
}

1482 1483
void
proto_cmd_show(struct proto *p, unsigned int verbose, int cnt)
1484
{
1485
  byte buf[256], tbuf[TM_DATETIME_BUFFER_SIZE];
1486

1487 1488 1489 1490
  /* First protocol - show header */
  if (!cnt)
    cli_msg(-2002, "name     proto    table    state  since       info");

1491 1492 1493
  buf[0] = 0;
  if (p->proto->get_status)
    p->proto->get_status(p, buf);
1494 1495
  tm_format_datetime(tbuf, &config->tf_proto, p->last_state_change);
  cli_msg(-1002, "%-8s %-8s %-8s %-5s  %-10s  %s",
1496 1497 1498 1499
	  p->name,
	  p->proto->name,
	  p->table->name,
	  proto_state_name(p),
1500
	  tbuf,
1501
	  buf);
1502 1503
  if (verbose)
    {
1504 1505
      if (p->cf->dsc)
	cli_msg(-1006, "  Description:    %s", p->cf->dsc);
1506 1507
      if (p->cf->router_id)
	cli_msg(-1006, "  Router ID:      %R", p->cf->router_id);
1508

1509 1510
      if (p->proto->show_proto_info)
	p->proto->show_proto_info(p);
1511 1512
      else
	proto_show_basic_info(p);
1513

1514
      cli_msg(-1006, "");
1515 1516 1517
    }
}

1518
void
1519
proto_cmd_disable(struct proto *p, unsigned int arg UNUSED, int cnt UNUSED)
1520
{