lib/nexthop.c

   1 /* A generic nexthop structure
   2  * Copyright (C) 2013 Cumulus Networks, Inc.
   3  *
   4  * This file is part of Quagga.
   5  *
   6  * Quagga 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  * Quagga 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 along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20 #include <zebra.h>
  21
  22 #include "prefix.h"
  23 #include "table.h"
  24 #include "memory.h"
  25 #include "command.h"
  26 #include "if.h"
  27 #include "log.h"
  28 #include "sockunion.h"
  29 #include "linklist.h"
  30 #include "thread.h"
  31 #include "prefix.h"
  32 #include "nexthop.h"
  33 #include "mpls.h"
  34 #include "jhash.h"
  35 #include "printfrr.h"
  36 #include "vrf.h"
  37
  38 DEFINE_MTYPE_STATIC(LIB, NEXTHOP, "Nexthop")
  39 DEFINE_MTYPE_STATIC(LIB, NH_LABEL, "Nexthop label")
  40
  41 static int _nexthop_labels_cmp(const struct nexthop *nh1,
  42                                const struct nexthop *nh2)
  43 {
  44         const struct mpls_label_stack *nhl1 = NULL;
  45         const struct mpls_label_stack *nhl2 = NULL;
  46
  47         nhl1 = nh1->nh_label;
  48         nhl2 = nh2->nh_label;
  49
  50         /* No labels is a match */
  51         if (!nhl1 && !nhl2)
  52                 return 0;
  53
  54         if (nhl1 && !nhl2)
  55                 return 1;
  56
  57         if (nhl2 && !nhl1)
  58                 return -1;
  59
  60         if (nhl1->num_labels > nhl2->num_labels)
  61                 return 1;
  62
  63         if (nhl1->num_labels < nhl2->num_labels)
  64                 return -1;
  65
  66         return memcmp(nhl1->label, nhl2->label, nhl1->num_labels);
  67 }
  68
  69 int nexthop_g_addr_cmp(enum nexthop_types_t type, const union g_addr *addr1,
  70                        const union g_addr *addr2)
  71 {
  72         int ret = 0;
  73
  74         switch (type) {
  75         case NEXTHOP_TYPE_IPV4:
  76         case NEXTHOP_TYPE_IPV4_IFINDEX:
  77                 ret = IPV4_ADDR_CMP(&addr1->ipv4, &addr2->ipv4);
  78                 break;
  79         case NEXTHOP_TYPE_IPV6:
  80         case NEXTHOP_TYPE_IPV6_IFINDEX:
  81                 ret = IPV6_ADDR_CMP(&addr1->ipv6, &addr2->ipv6);
  82                 break;
  83         case NEXTHOP_TYPE_IFINDEX:
  84         case NEXTHOP_TYPE_BLACKHOLE:
  85                 /* No addr here */
  86                 break;
  87         }
  88
  89         return ret;
  90 }
  91
  92 static int _nexthop_gateway_cmp(const struct nexthop *nh1,
  93                                 const struct nexthop *nh2)
  94 {
  95         return nexthop_g_addr_cmp(nh1->type, &nh1->gate, &nh2->gate);
  96 }
  97
  98 static int _nexthop_source_cmp(const struct nexthop *nh1,
  99                                const struct nexthop *nh2)
 100 {
 101         return nexthop_g_addr_cmp(nh1->type, &nh1->src, &nh2->src);
 102 }
 103
 104 static int _nexthop_cmp_no_labels(const struct nexthop *next1,
 105                                   const struct nexthop *next2)
 106 {
 107         int ret = 0;
 108
 109         if (next1->vrf_id < next2->vrf_id)
 110                 return -1;
 111
 112         if (next1->vrf_id > next2->vrf_id)
 113                 return 1;
 114
 115         if (next1->type < next2->type)
 116                 return -1;
 117
 118         if (next1->type > next2->type)
 119                 return 1;
 120
 121         if (next1->weight < next2->weight)
 122                 return -1;
 123
 124         if (next1->weight > next2->weight)
 125                 return 1;
 126
 127         switch (next1->type) {
 128         case NEXTHOP_TYPE_IPV4:
 129         case NEXTHOP_TYPE_IPV6:
 130                 ret = _nexthop_gateway_cmp(next1, next2);
 131                 if (ret != 0)
 132                         return ret;
 133                 break;
 134         case NEXTHOP_TYPE_IPV4_IFINDEX:
 135         case NEXTHOP_TYPE_IPV6_IFINDEX:
 136                 ret = _nexthop_gateway_cmp(next1, next2);
 137                 if (ret != 0)
 138                         return ret;
 139                 /* Intentional Fall-Through */
 140         case NEXTHOP_TYPE_IFINDEX:
 141                 if (next1->ifindex < next2->ifindex)
 142                         return -1;
 143
 144                 if (next1->ifindex > next2->ifindex)
 145                         return 1;
 146                 break;
 147         case NEXTHOP_TYPE_BLACKHOLE:
 148                 if (next1->bh_type < next2->bh_type)
 149                         return -1;
 150
 151                 if (next1->bh_type > next2->bh_type)
 152                         return 1;
 153                 break;
 154         }
 155
 156         ret = _nexthop_source_cmp(next1, next2);
 157
 158         return ret;
 159 }
 160
 161 int nexthop_cmp(const struct nexthop *next1, const struct nexthop *next2)
 162 {
 163         int ret = 0;
 164
 165         ret = _nexthop_cmp_no_labels(next1, next2);
 166         if (ret != 0)
 167                 return ret;
 168
 169         ret = _nexthop_labels_cmp(next1, next2);
 170
 171         return ret;
 172 }
 173
 174 int nexthop_same_firsthop(struct nexthop *next1, struct nexthop *next2)
 175 {
 176         int type1 = NEXTHOP_FIRSTHOPTYPE(next1->type);
 177         int type2 = NEXTHOP_FIRSTHOPTYPE(next2->type);
 178
 179         if (type1 != type2)
 180                 return 0;
 181         switch (type1) {
 182         case NEXTHOP_TYPE_IPV4_IFINDEX:
 183                 if (!IPV4_ADDR_SAME(&next1->gate.ipv4, &next2->gate.ipv4))
 184                         return 0;
 185                 if (next1->ifindex != next2->ifindex)
 186                         return 0;
 187                 break;
 188         case NEXTHOP_TYPE_IFINDEX:
 189                 if (next1->ifindex != next2->ifindex)
 190                         return 0;
 191                 break;
 192         case NEXTHOP_TYPE_IPV6_IFINDEX:
 193                 if (!IPV6_ADDR_SAME(&next1->gate.ipv6, &next2->gate.ipv6))
 194                         return 0;
 195                 if (next1->ifindex != next2->ifindex)
 196                         return 0;
 197                 break;
 198         default:
 199                 /* do nothing */
 200                 break;
 201         }
 202         return 1;
 203 }
 204
 205 /*
 206  * nexthop_type_to_str
 207  */
 208 const char *nexthop_type_to_str(enum nexthop_types_t nh_type)
 209 {
 210         static const char *const desc[] = {
 211                 "none",          "Directly connected",
 212                 "IPv4 nexthop",  "IPv4 nexthop with ifindex",
 213                 "IPv6 nexthop",  "IPv6 nexthop with ifindex",
 214                 "Null0 nexthop",
 215         };
 216
 217         return desc[nh_type];
 218 }
 219
 220 /*
 221  * Check if the labels match for the 2 nexthops specified.
 222  */
 223 bool nexthop_labels_match(const struct nexthop *nh1, const struct nexthop *nh2)
 224 {
 225         if (_nexthop_labels_cmp(nh1, nh2) != 0)
 226                 return false;
 227
 228         return true;
 229 }
 230
 231 struct nexthop *nexthop_new(void)
 232 {
 233         struct nexthop *nh;
 234
 235         nh = XCALLOC(MTYPE_NEXTHOP, sizeof(struct nexthop));
 236
 237         /*
 238          * Default the weight to 1 here for all nexthops.
 239          * The linux kernel does some weird stuff with adding +1 to
 240          * all nexthop weights it gets over netlink.
 241          * To handle this, just default everything to 1 right from
 242          * from the beggining so we don't have to special case
 243          * default weights in the linux netlink code.
 244          *
 245          * 1 should be a valid on all platforms anyway.
 246          */
 247         nh->weight = 1;
 248
 249         return nh;
 250 }
 251
 252 /* Free nexthop. */
 253 void nexthop_free(struct nexthop *nexthop)
 254 {
 255         nexthop_del_labels(nexthop);
 256         if (nexthop->resolved)
 257                 nexthops_free(nexthop->resolved);
 258         XFREE(MTYPE_NEXTHOP, nexthop);
 259 }
 260
 261 /* Frees a list of nexthops */
 262 void nexthops_free(struct nexthop *nexthop)
 263 {
 264         struct nexthop *nh, *next;
 265
 266         for (nh = nexthop; nh; nh = next) {
 267                 next = nh->next;
 268                 nexthop_free(nh);
 269         }
 270 }
 271
 272 bool nexthop_same(const struct nexthop *nh1, const struct nexthop *nh2)
 273 {
 274         if (nh1 && !nh2)
 275                 return false;
 276
 277         if (!nh1 && nh2)
 278                 return false;
 279
 280         if (nh1 == nh2)
 281                 return true;
 282
 283         if (nexthop_cmp(nh1, nh2) != 0)
 284                 return false;
 285
 286         return true;
 287 }
 288
 289 bool nexthop_same_no_labels(const struct nexthop *nh1,
 290                             const struct nexthop *nh2)
 291 {
 292         if (nh1 && !nh2)
 293                 return false;
 294
 295         if (!nh1 && nh2)
 296                 return false;
 297
 298         if (nh1 == nh2)
 299                 return true;
 300
 301         if (_nexthop_cmp_no_labels(nh1, nh2) != 0)
 302                 return false;
 303
 304         return true;
 305 }
 306
 307 /*
 308  * Allocate a new nexthop object and initialize it from various args.
 309  */
 310 struct nexthop *nexthop_from_ifindex(ifindex_t ifindex, vrf_id_t vrf_id)
 311 {
 312         struct nexthop *nexthop;
 313
 314         nexthop = nexthop_new();
 315         nexthop->type = NEXTHOP_TYPE_IFINDEX;
 316         nexthop->ifindex = ifindex;
 317         nexthop->vrf_id = vrf_id;
 318
 319         return nexthop;
 320 }
 321
 322 struct nexthop *nexthop_from_ipv4(const struct in_addr *ipv4,
 323                                   const struct in_addr *src,
 324                                   vrf_id_t vrf_id)
 325 {
 326         struct nexthop *nexthop;
 327
 328         nexthop = nexthop_new();
 329         nexthop->type = NEXTHOP_TYPE_IPV4;
 330         nexthop->vrf_id = vrf_id;
 331         nexthop->gate.ipv4 = *ipv4;
 332         if (src)
 333                 nexthop->src.ipv4 = *src;
 334
 335         return nexthop;
 336 }
 337
 338 struct nexthop *nexthop_from_ipv4_ifindex(const struct in_addr *ipv4,
 339                                           const struct in_addr *src,
 340                                           ifindex_t ifindex, vrf_id_t vrf_id)
 341 {
 342         struct nexthop *nexthop;
 343
 344         nexthop = nexthop_new();
 345         nexthop->type = NEXTHOP_TYPE_IPV4_IFINDEX;
 346         nexthop->vrf_id = vrf_id;
 347         nexthop->gate.ipv4 = *ipv4;
 348         if (src)
 349                 nexthop->src.ipv4 = *src;
 350         nexthop->ifindex = ifindex;
 351
 352         return nexthop;
 353 }
 354
 355 struct nexthop *nexthop_from_ipv6(const struct in6_addr *ipv6,
 356                                   vrf_id_t vrf_id)
 357 {
 358         struct nexthop *nexthop;
 359
 360         nexthop = nexthop_new();
 361         nexthop->vrf_id = vrf_id;
 362         nexthop->type = NEXTHOP_TYPE_IPV6;
 363         nexthop->gate.ipv6 = *ipv6;
 364
 365         return nexthop;
 366 }
 367
 368 struct nexthop *nexthop_from_ipv6_ifindex(const struct in6_addr *ipv6,
 369                                           ifindex_t ifindex, vrf_id_t vrf_id)
 370 {
 371         struct nexthop *nexthop;
 372
 373         nexthop = nexthop_new();
 374         nexthop->vrf_id = vrf_id;
 375         nexthop->type = NEXTHOP_TYPE_IPV6_IFINDEX;
 376         nexthop->gate.ipv6 = *ipv6;
 377         nexthop->ifindex = ifindex;
 378
 379         return nexthop;
 380 }
 381
 382 struct nexthop *nexthop_from_blackhole(enum blackhole_type bh_type)
 383 {
 384         struct nexthop *nexthop;
 385
 386         nexthop = nexthop_new();
 387         nexthop->vrf_id = VRF_DEFAULT;
 388         nexthop->type = NEXTHOP_TYPE_BLACKHOLE;
 389         nexthop->bh_type = bh_type;
 390
 391         return nexthop;
 392 }
 393
 394 /* Update nexthop with label information. */
 395 void nexthop_add_labels(struct nexthop *nexthop, enum lsp_types_t type,
 396                         uint8_t num_labels, mpls_label_t *label)
 397 {
 398         struct mpls_label_stack *nh_label;
 399         int i;
 400
 401         if (num_labels == 0)
 402                 return;
 403
 404         nexthop->nh_label_type = type;
 405         nh_label = XCALLOC(MTYPE_NH_LABEL,
 406                            sizeof(struct mpls_label_stack)
 407                                    + num_labels * sizeof(mpls_label_t));
 408         nh_label->num_labels = num_labels;
 409         for (i = 0; i < num_labels; i++)
 410                 nh_label->label[i] = *(label + i);
 411         nexthop->nh_label = nh_label;
 412 }
 413
 414 /* Free label information of nexthop, if present. */
 415 void nexthop_del_labels(struct nexthop *nexthop)
 416 {
 417         if (nexthop->nh_label) {
 418                 XFREE(MTYPE_NH_LABEL, nexthop->nh_label);
 419                 nexthop->nh_label_type = ZEBRA_LSP_NONE;
 420         }
 421 }
 422
 423 const char *nexthop2str(const struct nexthop *nexthop, char *str, int size)
 424 {
 425         switch (nexthop->type) {
 426         case NEXTHOP_TYPE_IFINDEX:
 427                 snprintf(str, size, "if %u", nexthop->ifindex);
 428                 break;
 429         case NEXTHOP_TYPE_IPV4:
 430         case NEXTHOP_TYPE_IPV4_IFINDEX:
 431                 snprintf(str, size, "%s if %u", inet_ntoa(nexthop->gate.ipv4),
 432                          nexthop->ifindex);
 433                 break;
 434         case NEXTHOP_TYPE_IPV6:
 435         case NEXTHOP_TYPE_IPV6_IFINDEX:
 436                 snprintf(str, size, "%s if %u", inet6_ntoa(nexthop->gate.ipv6),
 437                          nexthop->ifindex);
 438                 break;
 439         case NEXTHOP_TYPE_BLACKHOLE:
 440                 snprintf(str, size, "blackhole");
 441                 break;
 442         default:
 443                 snprintf(str, size, "unknown");
 444                 break;
 445         }
 446
 447         return str;
 448 }
 449
 450 /*
 451  * Iteration step for ALL_NEXTHOPS macro:
 452  * This is the tricky part. Check if `nexthop' has
 453  * NEXTHOP_FLAG_RECURSIVE set. If yes, this implies that `nexthop' has
 454  * at least one nexthop attached to `nexthop->resolved', which will be
 455  * the next one.
 456  *
 457  * If NEXTHOP_FLAG_RECURSIVE is not set, `nexthop' will progress in its
 458  * current chain. In case its current chain end is reached, it will move
 459  * upwards in the recursion levels and progress there. Whenever a step
 460  * forward in a chain is done, recursion will be checked again.
 461  * In a nustshell, it's equivalent to a pre-traversal order assuming that
 462  * left branch is 'resolved' and right branch is 'next':
 463  * https://en.wikipedia.org/wiki/Tree_traversal#/media/File:Sorted_binary_tree_preorder.svg
 464  */
 465 struct nexthop *nexthop_next(const struct nexthop *nexthop)
 466 {
 467         if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
 468                 return nexthop->resolved;
 469
 470         if (nexthop->next)
 471                 return nexthop->next;
 472
 473         for (struct nexthop *par = nexthop->rparent; par; par = par->rparent)
 474                 if (par->next)
 475                         return par->next;
 476
 477         return NULL;
 478 }
 479
 480 /* Return the next nexthop in the tree that is resolved and active */
 481 struct nexthop *nexthop_next_active_resolved(const struct nexthop *nexthop)
 482 {
 483         struct nexthop *next = nexthop_next(nexthop);
 484
 485         while (next
 486                && (CHECK_FLAG(next->flags, NEXTHOP_FLAG_RECURSIVE)
 487                    || !CHECK_FLAG(next->flags, NEXTHOP_FLAG_ACTIVE)))
 488                 next = nexthop_next(next);
 489
 490         return next;
 491 }
 492
 493 unsigned int nexthop_level(struct nexthop *nexthop)
 494 {
 495         unsigned int rv = 0;
 496
 497         for (struct nexthop *par = nexthop->rparent; par; par = par->rparent)
 498                 rv++;
 499
 500         return rv;
 501 }
 502
 503 /* Only hash word-sized things, let cmp do the rest. */
 504 uint32_t nexthop_hash_quick(const struct nexthop *nexthop)
 505 {
 506         uint32_t key = 0x45afe398;
 507
 508         key = jhash_3words(nexthop->type, nexthop->vrf_id,
 509                            nexthop->nh_label_type, key);
 510
 511         if (nexthop->nh_label) {
 512                 int labels = nexthop->nh_label->num_labels;
 513                 int i = 0;
 514
 515                 while (labels >= 3) {
 516                         key = jhash_3words(nexthop->nh_label->label[i],
 517                                            nexthop->nh_label->label[i + 1],
 518                                            nexthop->nh_label->label[i + 2],
 519                                            key);
 520                         labels -= 3;
 521                         i += 3;
 522                 }
 523
 524                 if (labels >= 2) {
 525                         key = jhash_2words(nexthop->nh_label->label[i],
 526                                            nexthop->nh_label->label[i + 1],
 527                                            key);
 528                         labels -= 2;
 529                         i += 2;
 530                 }
 531
 532                 if (labels >= 1)
 533                         key = jhash_1word(nexthop->nh_label->label[i], key);
 534         }
 535
 536         key = jhash_2words(nexthop->ifindex,
 537                            CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ONLINK),
 538                            key);
 539
 540         return key;
 541 }
 542
 543
 544 #define GATE_SIZE 4 /* Number of uint32_t words in struct g_addr */
 545
 546 /* For a more granular hash */
 547 uint32_t nexthop_hash(const struct nexthop *nexthop)
 548 {
 549         uint32_t gate_src_rmap_raw[GATE_SIZE * 3] = {};
 550         /* Get all the quick stuff */
 551         uint32_t key = nexthop_hash_quick(nexthop);
 552
 553         assert(((sizeof(nexthop->gate) + sizeof(nexthop->src)
 554                  + sizeof(nexthop->rmap_src))
 555                 / 3)
 556                == (GATE_SIZE * sizeof(uint32_t)));
 557
 558         memcpy(gate_src_rmap_raw, &nexthop->gate, GATE_SIZE);
 559         memcpy(gate_src_rmap_raw + GATE_SIZE, &nexthop->src, GATE_SIZE);
 560         memcpy(gate_src_rmap_raw + (2 * GATE_SIZE), &nexthop->rmap_src,
 561                GATE_SIZE);
 562
 563         key = jhash2(gate_src_rmap_raw, (GATE_SIZE * 3), key);
 564
 565         return key;
 566 }
 567
 568 void nexthop_copy(struct nexthop *copy, const struct nexthop *nexthop,
 569                   struct nexthop *rparent)
 570 {
 571         copy->vrf_id = nexthop->vrf_id;
 572         copy->ifindex = nexthop->ifindex;
 573         copy->type = nexthop->type;
 574         copy->flags = nexthop->flags;
 575         copy->weight = nexthop->weight;
 576         memcpy(&copy->gate, &nexthop->gate, sizeof(nexthop->gate));
 577         memcpy(&copy->src, &nexthop->src, sizeof(nexthop->src));
 578         memcpy(&copy->rmap_src, &nexthop->rmap_src, sizeof(nexthop->rmap_src));
 579         copy->rparent = rparent;
 580         if (nexthop->nh_label)
 581                 nexthop_add_labels(copy, nexthop->nh_label_type,
 582                                    nexthop->nh_label->num_labels,
 583                                    &nexthop->nh_label->label[0]);
 584 }
 585
 586 struct nexthop *nexthop_dup(const struct nexthop *nexthop,
 587                             struct nexthop *rparent)
 588 {
 589         struct nexthop *new = nexthop_new();
 590
 591         nexthop_copy(new, nexthop, rparent);
 592         return new;
 593 }
 594
 595 /*
 596  * nexthop printing variants:
 597  *      %pNHvv
 598  *              via 1.2.3.4
 599  *              via 1.2.3.4, eth0
 600  *              is directly connected, eth0
 601  *              unreachable (blackhole)
 602  *      %pNHv
 603  *              1.2.3.4
 604  *              1.2.3.4, via eth0
 605  *              directly connected, eth0
 606  *              unreachable (blackhole)
 607  *      %pNHs
 608  *              nexthop2str()
 609  */
 610 printfrr_ext_autoreg_p("NH", printfrr_nh)
 611 static ssize_t printfrr_nh(char *buf, size_t bsz, const char *fmt,
 612                            int prec, const void *ptr)
 613 {
 614         const struct nexthop *nexthop = ptr;
 615         struct fbuf fb = { .buf = buf, .pos = buf, .len = bsz - 1 };
 616         bool do_ifi = false;
 617         const char *s, *v_is = "", *v_via = "", *v_viaif = "via ";
 618         ssize_t ret = 3;
 619
 620         switch (fmt[2]) {
 621         case 'v':
 622                 if (fmt[3] == 'v') {
 623                         v_is = "is ";
 624                         v_via = "via ";
 625                         v_viaif = "";
 626                         ret++;
 627                 }
 628
 629                 switch (nexthop->type) {
 630                 case NEXTHOP_TYPE_IPV4:
 631                 case NEXTHOP_TYPE_IPV4_IFINDEX:
 632                         bprintfrr(&fb, "%s%pI4", v_via, &nexthop->gate.ipv4);
 633                         do_ifi = true;
 634                         break;
 635                 case NEXTHOP_TYPE_IPV6:
 636                 case NEXTHOP_TYPE_IPV6_IFINDEX:
 637                         bprintfrr(&fb, "%s%pI6", v_via, &nexthop->gate.ipv6);
 638                         do_ifi = true;
 639                         break;
 640                 case NEXTHOP_TYPE_IFINDEX:
 641                         bprintfrr(&fb, "%sdirectly connected, %s", v_is,
 642                                 ifindex2ifname(nexthop->ifindex,
 643                                                nexthop->vrf_id));
 644                         break;
 645                 case NEXTHOP_TYPE_BLACKHOLE:
 646                         switch (nexthop->bh_type) {
 647                         case BLACKHOLE_REJECT:
 648                                 s = " (ICMP unreachable)";
 649                                 break;
 650                         case BLACKHOLE_ADMINPROHIB:
 651                                 s = " (ICMP admin-prohibited)";
 652                                 break;
 653                         case BLACKHOLE_NULL:
 654                                 s = " (blackhole)";
 655                                 break;
 656                         default:
 657                                 s = "";
 658                                 break;
 659                         }
 660                         bprintfrr(&fb, "unreachable%s", s);
 661                         break;
 662                 default:
 663                         break;
 664                 }
 665                 if (do_ifi && nexthop->ifindex)
 666                         bprintfrr(&fb, ", %s%s", v_viaif, ifindex2ifname(
 667                                         nexthop->ifindex,
 668                                         nexthop->vrf_id));
 669
 670                 *fb.pos = '\0';
 671                 return ret;
 672         case 's':
 673                 nexthop2str(nexthop, buf, bsz);
 674                 return 3;
 675         }
 676         return 0;
 677 }