bgpd/rfapi/rfapi_encap_tlv.c

   1 /*
   2  * Copyright 2015-2016, LabN Consulting, L.L.C.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; see the file COPYING; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include "lib/zebra.h"
  20
  21 #include "lib/memory.h"
  22 #include "lib/prefix.h"
  23 #include "lib/table.h"
  24 #include "lib/vty.h"
  25
  26 #include "bgpd/bgpd.h"
  27 #include "bgpd/bgp_attr.h"
  28
  29 #include "bgpd/bgp_encap_types.h"
  30 #include "bgpd/bgp_encap_tlv.h"
  31
  32 #include "bgpd/rfapi/rfapi.h"
  33 #include "bgpd/rfapi/rfapi_encap_tlv.h"
  34 #include "bgpd/rfapi/rfapi_private.h"
  35 #include "bgpd/rfapi/rfapi_monitor.h"
  36 #include "bgpd/rfapi/rfapi_vty.h"
  37 #include "bgpd/rfapi/bgp_rfapi_cfg.h"
  38 #include "bgpd/rfapi/vnc_debug.h"
  39
  40 static void rfapi_add_endpoint_address_to_subtlv(
  41         struct bgp *bgp, struct rfapi_ip_addr *ea,
  42         struct bgp_tea_subtlv_remote_endpoint *subtlv)
  43 {
  44         subtlv->family = ea->addr_family;
  45         if (subtlv->family == AF_INET)
  46                 subtlv->ip_address.v4 = ea->addr.v4;
  47         else
  48                 subtlv->ip_address.v6 = ea->addr.v6;
  49         subtlv->as4 = htonl(bgp->as);
  50 }
  51
  52 bgp_encap_types
  53 rfapi_tunneltype_option_to_tlv(struct bgp *bgp, struct rfapi_ip_addr *ea,
  54                                struct rfapi_tunneltype_option *tto,
  55                                struct attr *attr, int always_add)
  56 {
  57
  58 #define _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(ttype)                                \
  59         if ((always_add                                                        \
  60              || (bgp->rfapi_cfg                                                \
  61                  && !CHECK_FLAG(bgp->rfapi_cfg->flags,                         \
  62                                 BGP_VNC_CONFIG_ADV_UN_METHOD_ENCAP)))          \
  63             && ea                                                              \
  64             && !CHECK_SUBTLV_FLAG(&tto->bgpinfo.ttype,                         \
  65                                   BGP_TEA_SUBTLV_REMOTE_ENDPOINT)) {           \
  66                 rfapi_add_endpoint_address_to_subtlv(                          \
  67                         bgp, ea, &tto->bgpinfo.ttype.st_endpoint);             \
  68                 SET_SUBTLV_FLAG(&tto->bgpinfo.ttype,                           \
  69                                 BGP_TEA_SUBTLV_REMOTE_ENDPOINT);               \
  70         }
  71
  72         struct rfapi_tunneltype_option dto;
  73         if (tto == NULL) { /* create default type */
  74                 tto = &dto;
  75                 memset(tto, 0, sizeof(dto));
  76                 tto->type = RFAPI_BGP_ENCAP_TYPE_DEFAULT;
  77         }
  78         switch (tto->type) {
  79         case BGP_ENCAP_TYPE_L2TPV3_OVER_IP:
  80                 _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(l2tpv3_ip);
  81                 bgp_encap_type_l2tpv3overip_to_tlv(&tto->bgpinfo.l2tpv3_ip,
  82                                                    attr);
  83                 break;
  84
  85         case BGP_ENCAP_TYPE_GRE:
  86                 _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(gre);
  87                 bgp_encap_type_gre_to_tlv(&tto->bgpinfo.gre, attr);
  88                 break;
  89
  90         case BGP_ENCAP_TYPE_TRANSMIT_TUNNEL_ENDPOINT:
  91                 _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(transmit_tunnel_endpoint);
  92                 bgp_encap_type_transmit_tunnel_endpoint(
  93                         &tto->bgpinfo.transmit_tunnel_endpoint, attr);
  94                 break;
  95
  96         case BGP_ENCAP_TYPE_IPSEC_IN_TUNNEL_MODE:
  97                 _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(ipsec_tunnel);
  98                 bgp_encap_type_ipsec_in_tunnel_mode_to_tlv(
  99                         &tto->bgpinfo.ipsec_tunnel, attr);
 100                 break;
 101
 102         case BGP_ENCAP_TYPE_IP_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE:
 103                 _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(ip_ipsec);
 104                 bgp_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode_to_tlv(
 105                         &tto->bgpinfo.ip_ipsec, attr);
 106                 break;
 107
 108         case BGP_ENCAP_TYPE_MPLS_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE:
 109                 _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(mpls_ipsec);
 110                 bgp_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode_to_tlv(
 111                         &tto->bgpinfo.mpls_ipsec, attr);
 112                 break;
 113
 114         case BGP_ENCAP_TYPE_IP_IN_IP:
 115                 _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(ip_ip);
 116                 bgp_encap_type_ip_in_ip_to_tlv(&tto->bgpinfo.ip_ip, attr);
 117                 break;
 118
 119         case BGP_ENCAP_TYPE_VXLAN:
 120                 _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(vxlan);
 121                 bgp_encap_type_vxlan_to_tlv(&tto->bgpinfo.vxlan, attr);
 122                 break;
 123
 124         case BGP_ENCAP_TYPE_NVGRE:
 125                 _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(nvgre);
 126                 bgp_encap_type_nvgre_to_tlv(&tto->bgpinfo.nvgre, attr);
 127                 break;
 128
 129         case BGP_ENCAP_TYPE_MPLS:
 130                 /* nothing to do for MPLS */
 131                 break;
 132
 133         case BGP_ENCAP_TYPE_MPLS_IN_GRE:
 134                 _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(mpls_gre);
 135                 bgp_encap_type_mpls_in_gre_to_tlv(&tto->bgpinfo.mpls_gre, attr);
 136                 break;
 137
 138         case BGP_ENCAP_TYPE_VXLAN_GPE:
 139                 _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(vxlan_gpe);
 140                 bgp_encap_type_vxlan_gpe_to_tlv(&tto->bgpinfo.vxlan_gpe, attr);
 141                 break;
 142
 143         case BGP_ENCAP_TYPE_MPLS_IN_UDP:
 144                 _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(mpls_udp);
 145                 bgp_encap_type_mpls_in_udp_to_tlv(&tto->bgpinfo.mpls_udp, attr);
 146                 break;
 147
 148         case BGP_ENCAP_TYPE_PBB:
 149                 _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(pbb);
 150                 bgp_encap_type_pbb_to_tlv(&tto->bgpinfo.pbb, attr);
 151                 break;
 152
 153         case BGP_ENCAP_TYPE_RESERVED:
 154                 assert(!"Cannot process BGP_ENCAP_TYPE_RESERVED");
 155         }
 156         return tto->type;
 157 }
 158
 159 struct rfapi_un_option *rfapi_encap_tlv_to_un_option(struct attr *attr)
 160 {
 161         struct rfapi_un_option *uo = NULL;
 162         struct rfapi_tunneltype_option *tto;
 163         int rc;
 164         struct bgp_attr_encap_subtlv *stlv;
 165
 166         /* no tunnel encap attr stored */
 167         if (!attr->encap_tunneltype)
 168                 return NULL;
 169
 170         stlv = attr->encap_subtlvs;
 171
 172         uo = XCALLOC(MTYPE_RFAPI_UN_OPTION, sizeof(struct rfapi_un_option));
 173         uo->type = RFAPI_UN_OPTION_TYPE_TUNNELTYPE;
 174         uo->v.tunnel.type = attr->encap_tunneltype;
 175         tto = &uo->v.tunnel;
 176
 177         switch (attr->encap_tunneltype) {
 178         case BGP_ENCAP_TYPE_L2TPV3_OVER_IP:
 179                 rc = tlv_to_bgp_encap_type_l2tpv3overip(
 180                         stlv, &tto->bgpinfo.l2tpv3_ip);
 181                 break;
 182
 183         case BGP_ENCAP_TYPE_GRE:
 184                 rc = tlv_to_bgp_encap_type_gre(stlv, &tto->bgpinfo.gre);
 185                 break;
 186
 187         case BGP_ENCAP_TYPE_TRANSMIT_TUNNEL_ENDPOINT:
 188                 rc = tlv_to_bgp_encap_type_transmit_tunnel_endpoint(
 189                         stlv, &tto->bgpinfo.transmit_tunnel_endpoint);
 190                 break;
 191
 192         case BGP_ENCAP_TYPE_IPSEC_IN_TUNNEL_MODE:
 193                 rc = tlv_to_bgp_encap_type_ipsec_in_tunnel_mode(
 194                         stlv, &tto->bgpinfo.ipsec_tunnel);
 195                 break;
 196
 197         case BGP_ENCAP_TYPE_IP_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE:
 198                 rc = tlv_to_bgp_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode(
 199                         stlv, &tto->bgpinfo.ip_ipsec);
 200                 break;
 201
 202         case BGP_ENCAP_TYPE_MPLS_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE:
 203                 rc = tlv_to_bgp_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode(
 204                         stlv, &tto->bgpinfo.mpls_ipsec);
 205                 break;
 206
 207         case BGP_ENCAP_TYPE_IP_IN_IP:
 208                 rc = tlv_to_bgp_encap_type_ip_in_ip(stlv, &tto->bgpinfo.ip_ip);
 209                 break;
 210
 211         case BGP_ENCAP_TYPE_VXLAN:
 212                 rc = tlv_to_bgp_encap_type_vxlan(stlv, &tto->bgpinfo.vxlan);
 213                 break;
 214
 215         case BGP_ENCAP_TYPE_NVGRE:
 216                 rc = tlv_to_bgp_encap_type_nvgre(stlv, &tto->bgpinfo.nvgre);
 217                 break;
 218
 219         case BGP_ENCAP_TYPE_MPLS:
 220                 rc = tlv_to_bgp_encap_type_mpls(stlv, &tto->bgpinfo.mpls);
 221                 break;
 222
 223         case BGP_ENCAP_TYPE_MPLS_IN_GRE:
 224                 rc = tlv_to_bgp_encap_type_mpls_in_gre(stlv,
 225                                                        &tto->bgpinfo.mpls_gre);
 226                 break;
 227
 228         case BGP_ENCAP_TYPE_VXLAN_GPE:
 229                 rc = tlv_to_bgp_encap_type_vxlan_gpe(stlv,
 230                                                      &tto->bgpinfo.vxlan_gpe);
 231                 break;
 232
 233         case BGP_ENCAP_TYPE_MPLS_IN_UDP:
 234                 rc = tlv_to_bgp_encap_type_mpls_in_udp(stlv,
 235                                                        &tto->bgpinfo.mpls_udp);
 236                 break;
 237
 238         case BGP_ENCAP_TYPE_PBB:
 239                 rc = tlv_to_bgp_encap_type_pbb(stlv, &tto->bgpinfo.pbb);
 240                 break;
 241
 242         default:
 243                 vnc_zlog_debug_verbose("%s: unknown tunnel type %d", __func__,
 244                                        attr->encap_tunneltype);
 245                 rc = -1;
 246                 break;
 247         }
 248         if (rc) {
 249                 XFREE(MTYPE_RFAPI_UN_OPTION, uo);
 250         }
 251         return uo;
 252 }
 253
 254 /***********************************************************************
 255  *                      SUBTLV PRINT
 256  ***********************************************************************/
 257
 258 static void subtlv_print_encap_l2tpv3_over_ip(
 259         void *stream, int column_offset,
 260         struct bgp_tea_subtlv_encap_l2tpv3_over_ip *st)
 261 {
 262         int (*fp)(void *, const char *, ...);
 263         struct vty *vty;
 264         void *out;
 265         const char *vty_newline;
 266
 267         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 268                 return;
 269         if (!st)
 270                 return;
 271
 272         fp(out, "%*s%s%s", column_offset, "", "SubTLV: Encap(L2TPv3 over IP)",
 273            vty_newline);
 274         fp(out, "%*s  SessionID: %d%s", column_offset, "", st->sessionid,
 275            vty_newline);
 276         fp(out, "%*s  Cookie: (length %d)%s", column_offset, "",
 277            st->cookie_length, vty_newline);
 278 }
 279
 280 static void subtlv_print_encap_gre(void *stream, int column_offset,
 281                                    struct bgp_tea_subtlv_encap_gre_key *st)
 282 {
 283         int (*fp)(void *, const char *, ...);
 284         struct vty *vty;
 285         void *out;
 286         const char *vty_newline;
 287
 288         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 289                 return;
 290         if (!st)
 291                 return;
 292
 293         fp(out, "%*s%s%s", column_offset, "", "SubTLV: Encap(GRE)",
 294            vty_newline);
 295         fp(out, "%*s  GRE key: %d (0x%x)%s", column_offset, "", st->gre_key,
 296            st->gre_key, vty_newline);
 297 }
 298
 299 static void subtlv_print_encap_pbb(void *stream, int column_offset,
 300                                    struct bgp_tea_subtlv_encap_pbb *st)
 301 {
 302         int (*fp)(void *, const char *, ...);
 303         struct vty *vty;
 304         void *out;
 305         const char *vty_newline;
 306
 307         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 308                 return;
 309         if (!st)
 310                 return;
 311
 312         fp(out, "%*s%s%s", column_offset, "", "SubTLV: Encap(PBB)",
 313            vty_newline);
 314         if (st->flag_isid) {
 315                 fp(out, "%*s  ISID: %d (0x%x)%s", column_offset, "", st->isid,
 316                    st->isid, vty_newline);
 317         }
 318         if (st->flag_vid) {
 319                 fp(out, "%*s  VID: %d (0x%x)%s", column_offset, "", st->vid,
 320                    st->vid, vty_newline);
 321         }
 322         fp(out, "%*s  MACADDR %02x:%02x:%02x:%02x:%02x:%02x%s", column_offset,
 323            "", st->macaddr[0], st->macaddr[1], st->macaddr[2], st->macaddr[3],
 324            st->macaddr[4], st->macaddr[5], vty_newline);
 325 }
 326
 327 static void subtlv_print_proto_type(void *stream, int column_offset,
 328                                     struct bgp_tea_subtlv_proto_type *st)
 329 {
 330         int (*fp)(void *, const char *, ...);
 331         struct vty *vty;
 332         void *out;
 333         const char *vty_newline;
 334
 335         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 336                 return;
 337         if (!st)
 338                 return;
 339
 340         fp(out, "%*s%s%s", column_offset, "", "SubTLV: Encap(Proto Type)",
 341            vty_newline);
 342         fp(out, "%*s  Proto %d (0x%x)%s", column_offset, "", st->proto,
 343            st->proto, vty_newline);
 344 }
 345
 346 static void subtlv_print_color(void *stream, int column_offset,
 347                                struct bgp_tea_subtlv_color *st)
 348 {
 349         int (*fp)(void *, const char *, ...);
 350         struct vty *vty;
 351         void *out;
 352         const char *vty_newline;
 353
 354         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 355                 return;
 356         if (!st)
 357                 return;
 358
 359         fp(out, "%*s%s%s", column_offset, "", "SubTLV: Color", vty_newline);
 360         fp(out, "%*s  Color: %d (0x%x)", column_offset, "", st->color,
 361            st->color, vty_newline);
 362 }
 363
 364 static void subtlv_print_ipsec_ta(void *stream, int column_offset,
 365                                   struct bgp_tea_subtlv_ipsec_ta *st)
 366 {
 367         int (*fp)(void *, const char *, ...);
 368         struct vty *vty;
 369         void *out;
 370         const char *vty_newline;
 371
 372         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 373                 return;
 374         if (!st)
 375                 return;
 376
 377         fp(out, "%*s%s%s", column_offset, "", "SubTLV: IPSEC TA", vty_newline);
 378         fp(out, "%*s  Authenticator Type: %d (0x%x)", column_offset, "",
 379            st->authenticator_type, st->authenticator_type, vty_newline);
 380         fp(out, "%*s  Authenticator: (length %d)", column_offset, "",
 381            st->authenticator_length, vty_newline);
 382 }
 383
 384 /***********************************************************************
 385  *                      TLV PRINT
 386  ***********************************************************************/
 387
 388 static void
 389 print_encap_type_l2tpv3overip(void *stream, int column_offset,
 390                               struct bgp_encap_type_l2tpv3_over_ip *bet)
 391 {
 392         const char *type = "L2TPv3 over IP";
 393         int (*fp)(void *, const char *, ...);
 394         struct vty *vty;
 395         void *out;
 396         const char *vty_newline;
 397
 398         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 399                 return;
 400         if (!bet)
 401                 return;
 402
 403         fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);
 404
 405         subtlv_print_encap_l2tpv3_over_ip(stream, column_offset + 2,
 406                                           &bet->st_encap);
 407         subtlv_print_proto_type(stream, column_offset + 2, &bet->st_proto);
 408         subtlv_print_color(stream, column_offset + 2, &bet->st_color);
 409 }
 410
 411 static void print_encap_type_gre(void *stream, int column_offset,
 412                                  struct bgp_encap_type_gre *bet)
 413 {
 414         const char *type = "GRE";
 415         int (*fp)(void *, const char *, ...);
 416         struct vty *vty;
 417         void *out;
 418         const char *vty_newline;
 419
 420         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 421                 return;
 422         if (!bet)
 423                 return;
 424
 425         fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);
 426
 427         subtlv_print_encap_gre(stream, column_offset + 2, &bet->st_encap);
 428         subtlv_print_proto_type(stream, column_offset + 2, &bet->st_proto);
 429         subtlv_print_color(stream, column_offset + 2, &bet->st_color);
 430 }
 431
 432 static void print_encap_type_ip_in_ip(void *stream, int column_offset,
 433                                       struct bgp_encap_type_ip_in_ip *bet)
 434 {
 435         const char *type = "IP in IP";
 436         int (*fp)(void *, const char *, ...);
 437         struct vty *vty;
 438         void *out;
 439         const char *vty_newline;
 440
 441         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 442                 return;
 443         if (!bet)
 444                 return;
 445
 446         fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);
 447
 448         subtlv_print_proto_type(stream, column_offset + 2, &bet->st_proto);
 449         subtlv_print_color(stream, column_offset + 2, &bet->st_color);
 450 }
 451
 452 static void print_encap_type_transmit_tunnel_endpoint(
 453         void *stream, int column_offset,
 454         struct bgp_encap_type_transmit_tunnel_endpoint *bet)
 455 {
 456         const char *type = "Transmit Tunnel Endpoint";
 457         int (*fp)(void *, const char *, ...);
 458         struct vty *vty;
 459         void *out;
 460         const char *vty_newline;
 461
 462         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 463                 return;
 464         if (!bet)
 465                 return;
 466
 467         fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);
 468
 469         /* no subtlvs for this type */
 470 }
 471
 472 static void print_encap_type_ipsec_in_tunnel_mode(
 473         void *stream, int column_offset,
 474         struct bgp_encap_type_ipsec_in_tunnel_mode *bet)
 475 {
 476         const char *type = "IPSEC in Tunnel mode";
 477         int (*fp)(void *, const char *, ...);
 478         struct vty *vty;
 479         void *out;
 480         const char *vty_newline;
 481
 482         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 483                 return;
 484         if (!bet)
 485                 return;
 486
 487         fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);
 488         subtlv_print_ipsec_ta(stream, column_offset + 2, &bet->st_ipsec_ta);
 489 }
 490
 491 static void print_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode(
 492         void *stream, int column_offset,
 493         struct bgp_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode *bet)
 494 {
 495         const char *type = "IP in IP Tunnel with IPSEC transport mode";
 496         int (*fp)(void *, const char *, ...);
 497         struct vty *vty;
 498         void *out;
 499         const char *vty_newline;
 500
 501         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 502                 return;
 503         if (!bet)
 504                 return;
 505
 506         fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);
 507
 508         subtlv_print_ipsec_ta(stream, column_offset + 2, &bet->st_ipsec_ta);
 509 }
 510
 511 static void print_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode(
 512         void *stream, int column_offset,
 513         struct bgp_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode *bet)
 514 {
 515         const char *type = "MPLS in IP Tunnel with IPSEC transport mode";
 516         int (*fp)(void *, const char *, ...);
 517         struct vty *vty;
 518         void *out;
 519         const char *vty_newline;
 520
 521         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 522                 return;
 523         if (!bet)
 524                 return;
 525
 526         fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);
 527
 528         subtlv_print_ipsec_ta(stream, column_offset + 2, &bet->st_ipsec_ta);
 529 }
 530
 531
 532 static void print_encap_type_pbb(void *stream, int column_offset,
 533                                  struct bgp_encap_type_pbb *bet)
 534 {
 535         const char *type = "PBB";
 536         int (*fp)(void *, const char *, ...);
 537         struct vty *vty;
 538         void *out;
 539         const char *vty_newline;
 540
 541         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 542                 return;
 543         if (!bet)
 544                 return;
 545
 546         fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);
 547
 548         subtlv_print_encap_pbb(stream, column_offset + 2, &bet->st_encap);
 549 }
 550
 551
 552 static void print_encap_type_vxlan(void *stream, int column_offset,
 553                                    struct bgp_encap_type_vxlan *bet)
 554 {
 555         const char *type = "VXLAN";
 556         int (*fp)(void *, const char *, ...);
 557         struct vty *vty;
 558         void *out;
 559         const char *vty_newline;
 560
 561         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 562                 return;
 563         if (!bet)
 564                 return;
 565
 566         fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);
 567
 568         /* no subtlvs for this type */
 569 }
 570
 571
 572 static void print_encap_type_nvgre(void *stream, int column_offset,
 573                                    struct bgp_encap_type_nvgre *bet)
 574 {
 575         const char *type = "NVGRE";
 576         int (*fp)(void *, const char *, ...);
 577         struct vty *vty;
 578         void *out;
 579         const char *vty_newline;
 580
 581         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 582                 return;
 583         if (!bet)
 584                 return;
 585
 586         fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);
 587
 588         /* no subtlvs for this type */
 589 }
 590
 591 static void print_encap_type_mpls(void *stream, int column_offset,
 592                                   struct bgp_encap_type_mpls *bet)
 593 {
 594         const char *type = "MPLS";
 595         int (*fp)(void *, const char *, ...);
 596         struct vty *vty;
 597         void *out;
 598         const char *vty_newline;
 599
 600         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 601                 return;
 602         if (!bet)
 603                 return;
 604
 605         fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);
 606
 607         /* no subtlvs for this type */
 608 }
 609
 610 static void print_encap_type_mpls_in_gre(void *stream, int column_offset,
 611                                          struct bgp_encap_type_mpls_in_gre *bet)
 612 {
 613         const char *type = "MPLS in GRE";
 614         int (*fp)(void *, const char *, ...);
 615         struct vty *vty;
 616         void *out;
 617         const char *vty_newline;
 618
 619         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 620                 return;
 621         if (!bet)
 622                 return;
 623
 624         fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);
 625
 626         /* no subtlvs for this type */
 627 }
 628
 629 static void print_encap_type_vxlan_gpe(void *stream, int column_offset,
 630                                        struct bgp_encap_type_vxlan_gpe *bet)
 631 {
 632         const char *type = "VXLAN GPE";
 633         int (*fp)(void *, const char *, ...);
 634         struct vty *vty;
 635         void *out;
 636         const char *vty_newline;
 637
 638         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 639                 return;
 640         if (!bet)
 641                 return;
 642
 643         fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);
 644
 645         /* no subtlvs for this type */
 646 }
 647
 648 static void print_encap_type_mpls_in_udp(void *stream, int column_offset,
 649                                          struct bgp_encap_type_mpls_in_udp *bet)
 650 {
 651         const char *type = "MPLS in UDP";
 652         int (*fp)(void *, const char *, ...);
 653         struct vty *vty;
 654         void *out;
 655         const char *vty_newline;
 656
 657         if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
 658                 return;
 659         if (!bet)
 660                 return;
 661
 662         fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);
 663
 664         /* no subtlvs for this type */
 665 }
 666
 667 void rfapi_print_tunneltype_option(void *stream, int column_offset,
 668                                    struct rfapi_tunneltype_option *tto)
 669 {
 670         switch (tto->type) {
 671         case BGP_ENCAP_TYPE_L2TPV3_OVER_IP:
 672                 print_encap_type_l2tpv3overip(stream, column_offset,
 673                                               &tto->bgpinfo.l2tpv3_ip);
 674                 break;
 675
 676         case BGP_ENCAP_TYPE_GRE:
 677                 print_encap_type_gre(stream, column_offset, &tto->bgpinfo.gre);
 678                 break;
 679
 680         case BGP_ENCAP_TYPE_TRANSMIT_TUNNEL_ENDPOINT:
 681                 print_encap_type_transmit_tunnel_endpoint(
 682                         stream, column_offset,
 683                         &tto->bgpinfo.transmit_tunnel_endpoint);
 684                 break;
 685
 686         case BGP_ENCAP_TYPE_IPSEC_IN_TUNNEL_MODE:
 687                 print_encap_type_ipsec_in_tunnel_mode(
 688                         stream, column_offset, &tto->bgpinfo.ipsec_tunnel);
 689                 break;
 690
 691         case BGP_ENCAP_TYPE_IP_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE:
 692                 print_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode(
 693                         stream, column_offset, &tto->bgpinfo.ip_ipsec);
 694                 break;
 695
 696         case BGP_ENCAP_TYPE_MPLS_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE:
 697                 print_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode(
 698                         stream, column_offset, &tto->bgpinfo.mpls_ipsec);
 699                 break;
 700
 701         case BGP_ENCAP_TYPE_IP_IN_IP:
 702                 print_encap_type_ip_in_ip(stream, column_offset,
 703                                           &tto->bgpinfo.ip_ip);
 704                 break;
 705
 706         case BGP_ENCAP_TYPE_VXLAN:
 707                 print_encap_type_vxlan(stream, column_offset,
 708                                        &tto->bgpinfo.vxlan);
 709                 break;
 710
 711         case BGP_ENCAP_TYPE_NVGRE:
 712                 print_encap_type_nvgre(stream, column_offset,
 713                                        &tto->bgpinfo.nvgre);
 714                 break;
 715
 716         case BGP_ENCAP_TYPE_MPLS:
 717                 print_encap_type_mpls(stream, column_offset,
 718                                       &tto->bgpinfo.mpls);
 719                 break;
 720
 721         case BGP_ENCAP_TYPE_MPLS_IN_GRE:
 722                 print_encap_type_mpls_in_gre(stream, column_offset,
 723                                              &tto->bgpinfo.mpls_gre);
 724                 break;
 725
 726         case BGP_ENCAP_TYPE_VXLAN_GPE:
 727                 print_encap_type_vxlan_gpe(stream, column_offset,
 728                                            &tto->bgpinfo.vxlan_gpe);
 729                 break;
 730
 731         case BGP_ENCAP_TYPE_MPLS_IN_UDP:
 732                 print_encap_type_mpls_in_udp(stream, column_offset,
 733                                              &tto->bgpinfo.mpls_udp);
 734                 break;
 735
 736         case BGP_ENCAP_TYPE_PBB:
 737                 print_encap_type_pbb(stream, column_offset, &tto->bgpinfo.pbb);
 738                 break;
 739
 740         case BGP_ENCAP_TYPE_RESERVED:
 741                 assert(!"Cannot process BGP_ENCAP_TYPE_RESERVED");
 742         }
 743 }