bgpd/bgp_damp.c

   1 /* BGP flap dampening
   2    Copyright (C) 2001 IP Infusion Inc.
   3
   4 This file is part of GNU Zebra.
   5
   6 GNU Zebra is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by the
   8 Free Software Foundation; either version 2, or (at your option) any
   9 later version.
  10
  11 GNU Zebra is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Zebra; see the file COPYING.  If not, write to the Free
  18 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19 02111-1307, USA.  */
  20
  21 #include <zebra.h>
  22 #include <math.h>
  23
  24 #include "prefix.h"
  25 #include "memory.h"
  26 #include "command.h"
  27 #include "log.h"
  28 #include "thread.h"
  29 #include "queue.h"
  30
  31 #include "bgpd/bgpd.h"
  32 #include "bgpd/bgp_damp.h"
  33 #include "bgpd/bgp_table.h"
  34 #include "bgpd/bgp_route.h"
  35 #include "bgpd/bgp_attr.h"
  36 #include "bgpd/bgp_advertise.h"
  37
  38 /* Global variable to access damping configuration */
  39 struct bgp_damp_config bgp_damp_cfg;
  40 static struct bgp_damp_config *damp = &bgp_damp_cfg;
  41
  42 /* Utility macro to add and delete BGP dampening information to no
  43    used list.  */
  44 #define BGP_DAMP_LIST_ADD(N,A)  BGP_INFO_ADD(N,A,no_reuse_list)
  45 #define BGP_DAMP_LIST_DEL(N,A)  BGP_INFO_DEL(N,A,no_reuse_list)
  46
  47 /* Calculate reuse list index by penalty value.  */
  48 static int
  49 bgp_reuse_index (int penalty)
  50 {
  51   unsigned int i;
  52   int index;
  53
  54   i = (int)(((double) penalty / damp->reuse_limit - 1.0) * damp->scale_factor);
  55
  56   if ( i >= damp->reuse_index_size )
  57     i = damp->reuse_index_size - 1;
  58
  59   index = damp->reuse_index[i] - damp->reuse_index[0];
  60
  61   return (damp->reuse_offset + index) % damp->reuse_list_size;
  62 }
  63
  64 /* Add BGP dampening information to reuse list.  */
  65 static void
  66 bgp_reuse_list_add (struct bgp_damp_info *bdi)
  67 {
  68   int index;
  69
  70   index = bdi->index = bgp_reuse_index (bdi->penalty);
  71
  72   bdi->prev = NULL;
  73   bdi->next = damp->reuse_list[index];
  74   if (damp->reuse_list[index])
  75     damp->reuse_list[index]->prev = bdi;
  76   damp->reuse_list[index] = bdi;
  77 }
  78
  79 /* Delete BGP dampening information from reuse list.  */
  80 static void
  81 bgp_reuse_list_delete (struct bgp_damp_info *bdi)
  82 {
  83   if (bdi->next)
  84     bdi->next->prev = bdi->prev;
  85   if (bdi->prev)
  86     bdi->prev->next = bdi->next;
  87   else
  88     damp->reuse_list[bdi->index] = bdi->next;
  89 }
  90
  91 /* Return decayed penalty value.  */
  92 int
  93 bgp_damp_decay (time_t tdiff, int penalty)
  94 {
  95   unsigned int i;
  96
  97   i = (int) ((double) tdiff / DELTA_T);
  98
  99   if (i == 0)
 100     return penalty;
 101
 102   if (i >= damp->decay_array_size)
 103     return 0;
 104
 105   return (int) (penalty * damp->decay_array[i]);
 106 }
 107
 108 /* Handler of reuse timer event.  Each route in the current reuse-list
 109    is evaluated.  RFC2439 Section 4.8.7.  */
 110 static int
 111 bgp_reuse_timer (struct thread *t)
 112 {
 113   struct bgp_damp_info *bdi;
 114   struct bgp_damp_info *next;
 115   time_t t_now, t_diff;
 116
 117   damp->t_reuse = NULL;
 118   damp->t_reuse =
 119     thread_add_timer (master, bgp_reuse_timer, NULL, DELTA_REUSE);
 120
 121   t_now = bgp_clock ();
 122
 123   /* 1.  save a pointer to the current zeroth queue head and zero the
 124      list head entry.  */
 125   bdi = damp->reuse_list[damp->reuse_offset];
 126   damp->reuse_list[damp->reuse_offset] = NULL;
 127
 128   /* 2.  set offset = modulo reuse-list-size ( offset + 1 ), thereby
 129      rotating the circular queue of list-heads.  */
 130   damp->reuse_offset = (damp->reuse_offset + 1) % damp->reuse_list_size;
 131
 132   /* 3. if ( the saved list head pointer is non-empty ) */
 133   for (; bdi; bdi = next)
 134     {
 135       struct bgp *bgp = bdi->binfo->peer->bgp;
 136
 137       next = bdi->next;
 138
 139       /* Set t-diff = t-now - t-updated.  */
 140       t_diff = t_now - bdi->t_updated;
 141
 142       /* Set figure-of-merit = figure-of-merit * decay-array-ok [t-diff] */
 143       bdi->penalty = bgp_damp_decay (t_diff, bdi->penalty);
 144
 145       /* Set t-updated = t-now.  */
 146       bdi->t_updated = t_now;
 147
 148       /* if (figure-of-merit < reuse).  */
 149       if (bdi->penalty < damp->reuse_limit)
 150         {
 151           /* Reuse the route.  */
 152           bgp_info_unset_flag (bdi->rn, bdi->binfo, BGP_INFO_DAMPED);
 153           bdi->suppress_time = 0;
 154
 155           if (bdi->lastrecord == BGP_RECORD_UPDATE)
 156             {
 157               bgp_info_unset_flag (bdi->rn, bdi->binfo, BGP_INFO_HISTORY);
 158               bgp_aggregate_increment (bgp, &bdi->rn->p, bdi->binfo,
 159                                        bdi->afi, bdi->safi);
 160               bgp_process (bgp, bdi->rn, bdi->afi, bdi->safi);
 161             }
 162
 163           if (bdi->penalty <= damp->reuse_limit / 2.0)
 164             bgp_damp_info_free (bdi, 1);
 165           else
 166             BGP_DAMP_LIST_ADD (damp, bdi);
 167         }
 168       else
 169         /* Re-insert into another list (See RFC2439 Section 4.8.6).  */
 170         bgp_reuse_list_add (bdi);
 171     }
 172
 173   return 0;
 174 }
 175
 176 /* A route becomes unreachable (RFC2439 Section 4.8.2).  */
 177 int
 178 bgp_damp_withdraw (struct bgp_info *binfo, struct bgp_node *rn,
 179                    afi_t afi, safi_t safi, int attr_change)
 180 {
 181   time_t t_now;
 182   struct bgp_damp_info *bdi = NULL;
 183   double last_penalty = 0;
 184
 185   t_now = bgp_clock ();
 186
 187   /* Processing Unreachable Messages.  */
 188   if (binfo->extra)
 189     bdi = binfo->extra->damp_info;
 190
 191   if (bdi == NULL)
 192     {
 193       /* If there is no previous stability history. */
 194
 195       /* RFC2439 said:
 196          1. allocate a damping structure.
 197          2. set figure-of-merit = 1.
 198          3. withdraw the route.  */
 199
 200       bdi =  XCALLOC (MTYPE_BGP_DAMP_INFO, sizeof (struct bgp_damp_info));
 201       bdi->binfo = binfo;
 202       bdi->rn = rn;
 203       bdi->penalty = (attr_change ? DEFAULT_PENALTY / 2 : DEFAULT_PENALTY);
 204       bdi->flap = 1;
 205       bdi->start_time = t_now;
 206       bdi->suppress_time = 0;
 207       bdi->index = -1;
 208       bdi->afi = afi;
 209       bdi->safi = safi;
 210       (bgp_info_extra_get (binfo))->damp_info = bdi;
 211       BGP_DAMP_LIST_ADD (damp, bdi);
 212     }
 213   else
 214     {
 215       last_penalty = bdi->penalty;
 216
 217       /* 1. Set t-diff = t-now - t-updated.  */
 218       bdi->penalty =
 219         (bgp_damp_decay (t_now - bdi->t_updated, bdi->penalty)
 220          + (attr_change ? DEFAULT_PENALTY / 2 : DEFAULT_PENALTY));
 221
 222       if (bdi->penalty > damp->ceiling)
 223         bdi->penalty = damp->ceiling;
 224
 225       bdi->flap++;
 226     }
 227
 228   assert ((rn == bdi->rn) && (binfo == bdi->binfo));
 229
 230   bdi->lastrecord = BGP_RECORD_WITHDRAW;
 231   bdi->t_updated = t_now;
 232
 233   /* Make this route as historical status.  */
 234   bgp_info_set_flag (rn, binfo, BGP_INFO_HISTORY);
 235
 236   /* Remove the route from a reuse list if it is on one.  */
 237   if (CHECK_FLAG (bdi->binfo->flags, BGP_INFO_DAMPED))
 238     {
 239       /* If decay rate isn't equal to 0, reinsert brn. */
 240       if (bdi->penalty != last_penalty)
 241         {
 242           bgp_reuse_list_delete (bdi);
 243           bgp_reuse_list_add (bdi);
 244         }
 245       return BGP_DAMP_SUPPRESSED;
 246     }
 247
 248   /* If not suppressed before, do annonunce this withdraw and
 249      insert into reuse_list.  */
 250   if (bdi->penalty >= damp->suppress_value)
 251     {
 252       bgp_info_set_flag (rn, binfo, BGP_INFO_DAMPED);
 253       bdi->suppress_time = t_now;
 254       BGP_DAMP_LIST_DEL (damp, bdi);
 255       bgp_reuse_list_add (bdi);
 256     }
 257
 258   return BGP_DAMP_USED;
 259 }
 260
 261 int
 262 bgp_damp_update (struct bgp_info *binfo, struct bgp_node *rn,
 263                  afi_t afi, safi_t safi)
 264 {
 265   time_t t_now;
 266   struct bgp_damp_info *bdi;
 267   int status;
 268
 269   if (!binfo->extra || !((bdi = binfo->extra->damp_info)))
 270     return BGP_DAMP_USED;
 271
 272   t_now = bgp_clock ();
 273   bgp_info_unset_flag (rn, binfo, BGP_INFO_HISTORY);
 274
 275   bdi->lastrecord = BGP_RECORD_UPDATE;
 276   bdi->penalty = bgp_damp_decay (t_now - bdi->t_updated, bdi->penalty);
 277
 278   if (! CHECK_FLAG (bdi->binfo->flags, BGP_INFO_DAMPED)
 279       && (bdi->penalty < damp->suppress_value))
 280     status = BGP_DAMP_USED;
 281   else if (CHECK_FLAG (bdi->binfo->flags, BGP_INFO_DAMPED)
 282            && (bdi->penalty < damp->reuse_limit) )
 283     {
 284       bgp_info_unset_flag (rn, binfo, BGP_INFO_DAMPED);
 285       bgp_reuse_list_delete (bdi);
 286       BGP_DAMP_LIST_ADD (damp, bdi);
 287       bdi->suppress_time = 0;
 288       status = BGP_DAMP_USED;
 289     }
 290   else
 291     status = BGP_DAMP_SUPPRESSED;
 292
 293   if (bdi->penalty > damp->reuse_limit / 2.0)
 294     bdi->t_updated = t_now;
 295   else
 296     bgp_damp_info_free (bdi, 0);
 297
 298   return status;
 299 }
 300
 301 /* Remove dampening information and history route.  */
 302 int
 303 bgp_damp_scan (struct bgp_info *binfo, afi_t afi, safi_t safi)
 304 {
 305   time_t t_now, t_diff;
 306   struct bgp_damp_info *bdi;
 307
 308   assert (binfo->extra && binfo->extra->damp_info);
 309
 310   t_now = bgp_clock ();
 311   bdi = binfo->extra->damp_info;
 312
 313   if (CHECK_FLAG (binfo->flags, BGP_INFO_DAMPED))
 314     {
 315       t_diff = t_now - bdi->suppress_time;
 316
 317       if (t_diff >= damp->max_suppress_time)
 318         {
 319           bgp_info_unset_flag (bdi->rn, binfo, BGP_INFO_DAMPED);
 320           bgp_reuse_list_delete (bdi);
 321           BGP_DAMP_LIST_ADD (damp, bdi);
 322           bdi->penalty = damp->reuse_limit;
 323           bdi->suppress_time = 0;
 324           bdi->t_updated = t_now;
 325
 326           /* Need to announce UPDATE once this binfo is usable again. */
 327           if (bdi->lastrecord == BGP_RECORD_UPDATE)
 328             return 1;
 329           else
 330             return 0;
 331         }
 332     }
 333   else
 334     {
 335       t_diff = t_now - bdi->t_updated;
 336       bdi->penalty = bgp_damp_decay (t_diff, bdi->penalty);
 337
 338       if (bdi->penalty <= damp->reuse_limit / 2.0)
 339         {
 340           /* release the bdi, bdi->binfo. */
 341           bgp_damp_info_free (bdi, 1);
 342           return 0;
 343         }
 344       else
 345         bdi->t_updated = t_now;
 346     }
 347   return 0;
 348 }
 349
 350 void
 351 bgp_damp_info_free (struct bgp_damp_info *bdi, int withdraw)
 352 {
 353   struct bgp_info *binfo;
 354
 355   if (! bdi)
 356     return;
 357
 358   binfo = bdi->binfo;
 359   binfo->extra->damp_info = NULL;
 360
 361   if (CHECK_FLAG (binfo->flags, BGP_INFO_DAMPED))
 362     bgp_reuse_list_delete (bdi);
 363   else
 364     BGP_DAMP_LIST_DEL (damp, bdi);
 365
 366   bgp_info_unset_flag (bdi->rn, binfo, BGP_INFO_HISTORY|BGP_INFO_DAMPED);
 367
 368   if (bdi->lastrecord == BGP_RECORD_WITHDRAW && withdraw)
 369     bgp_info_delete (bdi->rn, binfo);
 370
 371   XFREE (MTYPE_BGP_DAMP_INFO, bdi);
 372 }
 373
 374 static void
 375 bgp_damp_parameter_set (int hlife, int reuse, int sup, int maxsup)
 376 {
 377   double reuse_max_ratio;
 378   unsigned int i;
 379   double j;
 380
 381   damp->suppress_value = sup;
 382   damp->half_life = hlife;
 383   damp->reuse_limit = reuse;
 384   damp->max_suppress_time = maxsup;
 385
 386   /* Initialize params per bgp_damp_config. */
 387   damp->reuse_index_size = REUSE_ARRAY_SIZE;
 388
 389   damp->ceiling = (int)(damp->reuse_limit * (pow(2, (double)damp->max_suppress_time/damp->half_life)));
 390
 391   /* Decay-array computations */
 392   damp->decay_array_size = ceil ((double) damp->max_suppress_time / DELTA_T);
 393   damp->decay_array = XMALLOC (MTYPE_BGP_DAMP_ARRAY,
 394                                sizeof(double) * (damp->decay_array_size));
 395   damp->decay_array[0] = 1.0;
 396   damp->decay_array[1] = exp ((1.0/((double)damp->half_life/DELTA_T)) * log(0.5));
 397
 398   /* Calculate decay values for all possible times */
 399   for (i = 2; i < damp->decay_array_size; i++)
 400     damp->decay_array[i] = damp->decay_array[i-1] * damp->decay_array[1];
 401
 402   /* Reuse-list computations */
 403   i = ceil ((double)damp->max_suppress_time / DELTA_REUSE) + 1;
 404   if (i > REUSE_LIST_SIZE || i == 0)
 405     i = REUSE_LIST_SIZE;
 406   damp->reuse_list_size = i;
 407
 408   damp->reuse_list = XCALLOC (MTYPE_BGP_DAMP_ARRAY,
 409                               damp->reuse_list_size
 410                               * sizeof (struct bgp_reuse_node *));
 411
 412   /* Reuse-array computations */
 413   damp->reuse_index = XCALLOC (MTYPE_BGP_DAMP_ARRAY,
 414                                sizeof(int) * damp->reuse_index_size);
 415
 416   reuse_max_ratio = (double)damp->ceiling/damp->reuse_limit;
 417   j = (exp((double)damp->max_suppress_time/damp->half_life) * log10(2.0));
 418   if ( reuse_max_ratio > j && j != 0 )
 419     reuse_max_ratio = j;
 420
 421   damp->scale_factor = (double)damp->reuse_index_size/(reuse_max_ratio - 1);
 422
 423   for (i = 0; i < damp->reuse_index_size; i++)
 424     {
 425       damp->reuse_index[i] =
 426         (int)(((double)damp->half_life / DELTA_REUSE)
 427               * log10 (1.0 / (damp->reuse_limit * ( 1.0 + ((double)i/damp->scale_factor)))) / log10(0.5));
 428     }
 429 }
 430
 431 int
 432 bgp_damp_enable (struct bgp *bgp, afi_t afi, safi_t safi, time_t half,
 433                  unsigned int reuse, unsigned int suppress, time_t max)
 434 {
 435   if (CHECK_FLAG (bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING))
 436     {
 437       if (damp->half_life == half
 438           && damp->reuse_limit == reuse
 439           && damp->suppress_value == suppress
 440           && damp->max_suppress_time == max)
 441         return 0;
 442       bgp_damp_disable (bgp, afi, safi);
 443     }
 444
 445   SET_FLAG (bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING);
 446   bgp_damp_parameter_set (half, reuse, suppress, max);
 447
 448   /* Register reuse timer.  */
 449   if (! damp->t_reuse)
 450     damp->t_reuse =
 451       thread_add_timer (master, bgp_reuse_timer, NULL, DELTA_REUSE);
 452
 453   return 0;
 454 }
 455
 456 static void
 457 bgp_damp_config_clean (struct bgp_damp_config *damp)
 458 {
 459   /* Free decay array */
 460   XFREE (MTYPE_BGP_DAMP_ARRAY, damp->decay_array);
 461
 462   /* Free reuse index array */
 463   XFREE (MTYPE_BGP_DAMP_ARRAY, damp->reuse_index);
 464
 465   /* Free reuse list array. */
 466   XFREE (MTYPE_BGP_DAMP_ARRAY, damp->reuse_list);
 467 }
 468
 469 /* Clean all the bgp_damp_info stored in reuse_list. */
 470 void
 471 bgp_damp_info_clean (void)
 472 {
 473   unsigned int i;
 474   struct bgp_damp_info *bdi, *next;
 475
 476   damp->reuse_offset = 0;
 477
 478   for (i = 0; i < damp->reuse_list_size; i++)
 479     {
 480       if (! damp->reuse_list[i])
 481         continue;
 482
 483       for (bdi = damp->reuse_list[i]; bdi; bdi = next)
 484         {
 485           next = bdi->next;
 486           bgp_damp_info_free (bdi, 1);
 487         }
 488       damp->reuse_list[i] = NULL;
 489     }
 490
 491   for (bdi = damp->no_reuse_list; bdi; bdi = next)
 492     {
 493       next = bdi->next;
 494       bgp_damp_info_free (bdi, 1);
 495     }
 496   damp->no_reuse_list = NULL;
 497 }
 498
 499 int
 500 bgp_damp_disable (struct bgp *bgp, afi_t afi, safi_t safi)
 501 {
 502   /* If it wasn't enabled, there's nothing to do. */
 503   if (! CHECK_FLAG (bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING))
 504     return 0;
 505
 506   /* Cancel reuse thread. */
 507   if (damp->t_reuse )
 508     thread_cancel (damp->t_reuse);
 509   damp->t_reuse = NULL;
 510
 511   /* Clean BGP dampening information.  */
 512   bgp_damp_info_clean ();
 513
 514   /* Clear configuration */
 515   bgp_damp_config_clean (&bgp_damp_cfg);
 516
 517   UNSET_FLAG (bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING);
 518   return 0;
 519 }
 520
 521 void
 522 bgp_config_write_damp (struct vty *vty)
 523 {
 524   if (bgp_damp_cfg.half_life == DEFAULT_HALF_LIFE*60
 525       && bgp_damp_cfg.reuse_limit == DEFAULT_REUSE
 526       && bgp_damp_cfg.suppress_value == DEFAULT_SUPPRESS
 527       && bgp_damp_cfg.max_suppress_time == bgp_damp_cfg.half_life*4)
 528     vty_out (vty, " bgp dampening%s", VTY_NEWLINE);
 529   else if (bgp_damp_cfg.half_life != DEFAULT_HALF_LIFE*60
 530            && bgp_damp_cfg.reuse_limit == DEFAULT_REUSE
 531            && bgp_damp_cfg.suppress_value == DEFAULT_SUPPRESS
 532            && bgp_damp_cfg.max_suppress_time == bgp_damp_cfg.half_life*4)
 533     vty_out (vty, " bgp dampening %ld%s",
 534              bgp_damp_cfg.half_life/60,
 535              VTY_NEWLINE);
 536   else
 537     vty_out (vty, " bgp dampening %ld %d %d %ld%s",
 538              bgp_damp_cfg.half_life/60,
 539              bgp_damp_cfg.reuse_limit,
 540              bgp_damp_cfg.suppress_value,
 541              bgp_damp_cfg.max_suppress_time/60,
 542              VTY_NEWLINE);
 543 }
 544
 545 static const char *
 546 bgp_get_reuse_time (unsigned int penalty, char *buf, size_t len, u_char use_json, json_object *json)
 547 {
 548   time_t reuse_time = 0;
 549   struct tm *tm = NULL;
 550   int time_store = 0;
 551
 552   if (penalty > damp->reuse_limit)
 553     {
 554       reuse_time = (int) (DELTA_T * ((log((double)damp->reuse_limit/penalty))/(log(damp->decay_array[1]))));
 555
 556       if (reuse_time > damp->max_suppress_time)
 557         reuse_time = damp->max_suppress_time;
 558
 559       tm = gmtime (&reuse_time);
 560     }
 561   else
 562     reuse_time = 0;
 563
 564   /* Making formatted timer strings. */
 565 #define ONE_DAY_SECOND 60*60*24
 566 #define ONE_WEEK_SECOND 60*60*24*7
 567   if (reuse_time == 0)
 568     {
 569       if (use_json)
 570         json_object_int_add(json, "reuseTimerMsecs", 0);
 571       else
 572         snprintf (buf, len, "00:00:00");
 573     }
 574   else if (reuse_time < ONE_DAY_SECOND)
 575     {
 576       if (use_json)
 577         {
 578           time_store = (3600000 * tm->tm_hour) + (60000 * tm->tm_min) + (1000 * tm->tm_sec);
 579           json_object_int_add(json, "reuseTimerMsecs", time_store);
 580         }
 581       else
 582         snprintf (buf, len, "%02d:%02d:%02d",
 583                 tm->tm_hour, tm->tm_min, tm->tm_sec);
 584     }
 585   else if (reuse_time < ONE_WEEK_SECOND)
 586     {
 587       if (use_json)
 588         {
 589           time_store = (86400000 * tm->tm_yday) + (3600000 * tm->tm_hour) + (60000 * tm->tm_min) + (1000 * tm->tm_sec);
 590           json_object_int_add(json, "reuseTimerMsecs", time_store);
 591         }
 592       else
 593         snprintf (buf, len, "%dd%02dh%02dm",
 594                 tm->tm_yday, tm->tm_hour, tm->tm_min);
 595     }
 596   else
 597     {
 598       if (use_json)
 599         {
 600           time_store = (604800000 * tm->tm_yday/7) + (86400000 * (tm->tm_yday - ((tm->tm_yday/7) * 7))) + (3600000 * tm->tm_hour) + (60000 * tm->tm_min) + (1000 * tm->tm_sec);
 601           json_object_int_add(json, "reuseTimerMsecs", time_store);
 602         }
 603       else
 604         snprintf (buf, len, "%02dw%dd%02dh",
 605                 tm->tm_yday/7, tm->tm_yday - ((tm->tm_yday/7) * 7), tm->tm_hour);
 606     }
 607
 608   return buf;
 609 }
 610
 611 void
 612 bgp_damp_info_vty (struct vty *vty, struct bgp_info *binfo,
 613                    json_object *json_path)
 614 {
 615   struct bgp_damp_info *bdi;
 616   time_t t_now, t_diff;
 617   char timebuf[BGP_UPTIME_LEN];
 618   int penalty;
 619
 620   if (!binfo->extra)
 621     return;
 622
 623   /* BGP dampening information.  */
 624   bdi = binfo->extra->damp_info;
 625
 626   /* If dampening is not enabled or there is no dampening information,
 627      return immediately.  */
 628   if (! damp || ! bdi)
 629     return;
 630
 631   /* Calculate new penalty.  */
 632   t_now = bgp_clock ();
 633   t_diff = t_now - bdi->t_updated;
 634   penalty = bgp_damp_decay (t_diff, bdi->penalty);
 635
 636   if (json_path)
 637     {
 638       json_object_int_add(json_path, "dampeningPenalty", penalty);
 639       json_object_int_add(json_path, "dampeningFlapCount", bdi->flap);
 640       peer_uptime (bdi->start_time, timebuf, BGP_UPTIME_LEN, 1, json_path);
 641
 642       if (CHECK_FLAG (binfo->flags, BGP_INFO_DAMPED)
 643           && ! CHECK_FLAG (binfo->flags, BGP_INFO_HISTORY))
 644         bgp_get_reuse_time (penalty, timebuf, BGP_UPTIME_LEN, 1, json_path);
 645     }
 646   else
 647     {
 648       vty_out (vty, "      Dampinfo: penalty %d, flapped %d times in %s",
 649                penalty, bdi->flap,
 650                peer_uptime (bdi->start_time, timebuf, BGP_UPTIME_LEN, 0, json_path));
 651
 652       if (CHECK_FLAG (binfo->flags, BGP_INFO_DAMPED)
 653           && ! CHECK_FLAG (binfo->flags, BGP_INFO_HISTORY))
 654         vty_out (vty, ", reuse in %s",
 655                bgp_get_reuse_time (penalty, timebuf, BGP_UPTIME_LEN, 0, json_path));
 656
 657       vty_out (vty, "%s", VTY_NEWLINE);
 658     }
 659 }
 660
 661 const char *
 662 bgp_damp_reuse_time_vty (struct vty *vty, struct bgp_info *binfo,
 663                          char *timebuf, size_t len, u_char use_json, json_object *json)
 664 {
 665   struct bgp_damp_info *bdi;
 666   time_t t_now, t_diff;
 667   int penalty;
 668
 669   if (!binfo->extra)
 670     return NULL;
 671
 672   /* BGP dampening information.  */
 673   bdi = binfo->extra->damp_info;
 674
 675   /* If dampening is not enabled or there is no dampening information,
 676      return immediately.  */
 677   if (! damp || ! bdi)
 678     return NULL;
 679
 680   /* Calculate new penalty.  */
 681   t_now = bgp_clock ();
 682   t_diff = t_now - bdi->t_updated;
 683   penalty = bgp_damp_decay (t_diff, bdi->penalty);
 684
 685   return  bgp_get_reuse_time (penalty, timebuf, len, use_json, json);
 686 }