// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * Copyright 2015-2016, LabN Consulting, L.L.C.

 */

#include "lib/zebra.h"

#include "lib/memory.h"

#include "lib/prefix.h"

#include "lib/table.h"

#include "lib/vty.h"

#include "bgpd/bgpd.h"

#include "bgpd/bgp_attr.h"

#include "bgpd/bgp_encap_types.h"

#include "bgpd/bgp_encap_tlv.h"

#include "bgpd/rfapi/rfapi.h"

#include "bgpd/rfapi/rfapi_encap_tlv.h"

#include "bgpd/rfapi/rfapi_private.h"

#include "bgpd/rfapi/rfapi_monitor.h"

#include "bgpd/rfapi/rfapi_vty.h"

#include "bgpd/rfapi/bgp_rfapi_cfg.h"

#include "bgpd/rfapi/vnc_debug.h"

static void rfapi_add_endpoint_address_to_subtlv(

  struct bgp *bgp, struct rfapi_ip_addr *ea,

  struct bgp_tea_subtlv_remote_endpoint *subtlv)

{

  subtlv->family = ea->addr_family;

  if (subtlv->family == AF_INET)

    subtlv->ip_address.v4 = ea->addr.v4;

  else

    subtlv->ip_address.v6 = ea->addr.v6;

  subtlv->as4 = htonl(bgp->as);

}

bgp_encap_types

rfapi_tunneltype_option_to_tlv(struct bgp *bgp, struct rfapi_ip_addr *ea,

             struct rfapi_tunneltype_option *tto,

             struct attr *attr, int always_add)

{

#define _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(ttype)                                \

  if ((always_add                                                        \

       || (bgp->rfapi_cfg                                                \

     && !CHECK_FLAG(bgp->rfapi_cfg->flags,                         \

        BGP_VNC_CONFIG_ADV_UN_METHOD_ENCAP)))          \

      && ea                                                              \

      && !CHECK_SUBTLV_FLAG(&tto->bgpinfo.ttype,                         \

          BGP_TEA_SUBTLV_REMOTE_ENDPOINT)) {           \

    rfapi_add_endpoint_address_to_subtlv(                          \

      bgp, ea, &tto->bgpinfo.ttype.st_endpoint);             \

    SET_SUBTLV_FLAG(&tto->bgpinfo.ttype,                           \

        BGP_TEA_SUBTLV_REMOTE_ENDPOINT);               \

  }

  struct rfapi_tunneltype_option dto;

  if (tto == NULL) { /* create default type */

    tto = &dto;

    memset(tto, 0, sizeof(dto));

    tto->type = RFAPI_BGP_ENCAP_TYPE_DEFAULT;

  }

  switch (tto->type) {

  case BGP_ENCAP_TYPE_L2TPV3_OVER_IP:

    _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(l2tpv3_ip);

    bgp_encap_type_l2tpv3overip_to_tlv(&tto->bgpinfo.l2tpv3_ip,

               attr);

    break;

  case BGP_ENCAP_TYPE_GRE:

    _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(gre);

    bgp_encap_type_gre_to_tlv(&tto->bgpinfo.gre, attr);

    break;

  case BGP_ENCAP_TYPE_TRANSMIT_TUNNEL_ENDPOINT:

    _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(transmit_tunnel_endpoint);

    bgp_encap_type_transmit_tunnel_endpoint(

      &tto->bgpinfo.transmit_tunnel_endpoint, attr);

    break;

  case BGP_ENCAP_TYPE_IPSEC_IN_TUNNEL_MODE:

    _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(ipsec_tunnel);

    bgp_encap_type_ipsec_in_tunnel_mode_to_tlv(

      &tto->bgpinfo.ipsec_tunnel, attr);

    break;

  case BGP_ENCAP_TYPE_IP_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE:

    _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(ip_ipsec);

    bgp_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode_to_tlv(

      &tto->bgpinfo.ip_ipsec, attr);

    break;

  case BGP_ENCAP_TYPE_MPLS_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE:

    _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(mpls_ipsec);

    bgp_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode_to_tlv(

      &tto->bgpinfo.mpls_ipsec, attr);

    break;

  case BGP_ENCAP_TYPE_IP_IN_IP:

    _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(ip_ip);

    bgp_encap_type_ip_in_ip_to_tlv(&tto->bgpinfo.ip_ip, attr);

    break;

  case BGP_ENCAP_TYPE_VXLAN:

    _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(vxlan);

    bgp_encap_type_vxlan_to_tlv(&tto->bgpinfo.vxlan, attr);

    break;

  case BGP_ENCAP_TYPE_NVGRE:

    _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(nvgre);

    bgp_encap_type_nvgre_to_tlv(&tto->bgpinfo.nvgre, attr);

    break;

  case BGP_ENCAP_TYPE_MPLS:

    /* nothing to do for MPLS */

    break;

  case BGP_ENCAP_TYPE_MPLS_IN_GRE:

    _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(mpls_gre);

    bgp_encap_type_mpls_in_gre_to_tlv(&tto->bgpinfo.mpls_gre, attr);

    break;

  case BGP_ENCAP_TYPE_VXLAN_GPE:

    _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(vxlan_gpe);

    bgp_encap_type_vxlan_gpe_to_tlv(&tto->bgpinfo.vxlan_gpe, attr);

    break;

  case BGP_ENCAP_TYPE_MPLS_IN_UDP:

    _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(mpls_udp);

    bgp_encap_type_mpls_in_udp_to_tlv(&tto->bgpinfo.mpls_udp, attr);

    break;

  case BGP_ENCAP_TYPE_PBB:

    _RTTO_MAYBE_ADD_ENDPOINT_ADDRESS(pbb);

    bgp_encap_type_pbb_to_tlv(&tto->bgpinfo.pbb, attr);

    break;

  case BGP_ENCAP_TYPE_RESERVED:

    assert(!"Cannot process BGP_ENCAP_TYPE_RESERVED");

  }

  return tto->type;

}

struct rfapi_un_option *rfapi_encap_tlv_to_un_option(struct attr *attr)

{

  struct rfapi_un_option *uo = NULL;

  struct rfapi_tunneltype_option *tto;

  int rc;

  struct bgp_attr_encap_subtlv *stlv;

  /* no tunnel encap attr stored */

  if (!attr->encap_tunneltype)

    return NULL;

  stlv = attr->encap_subtlvs;

  uo = XCALLOC(MTYPE_RFAPI_UN_OPTION, sizeof(struct rfapi_un_option));

  uo->type = RFAPI_UN_OPTION_TYPE_TUNNELTYPE;

  uo->v.tunnel.type = attr->encap_tunneltype;

  tto = &uo->v.tunnel;

  switch (attr->encap_tunneltype) {

  case BGP_ENCAP_TYPE_L2TPV3_OVER_IP:

    rc = tlv_to_bgp_encap_type_l2tpv3overip(

      stlv, &tto->bgpinfo.l2tpv3_ip);

    break;

  case BGP_ENCAP_TYPE_GRE:

    rc = tlv_to_bgp_encap_type_gre(stlv, &tto->bgpinfo.gre);

    break;

  case BGP_ENCAP_TYPE_TRANSMIT_TUNNEL_ENDPOINT:

    rc = tlv_to_bgp_encap_type_transmit_tunnel_endpoint(

      stlv, &tto->bgpinfo.transmit_tunnel_endpoint);

    break;

  case BGP_ENCAP_TYPE_IPSEC_IN_TUNNEL_MODE:

    rc = tlv_to_bgp_encap_type_ipsec_in_tunnel_mode(

      stlv, &tto->bgpinfo.ipsec_tunnel);

    break;

  case BGP_ENCAP_TYPE_IP_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE:

    rc = tlv_to_bgp_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode(

      stlv, &tto->bgpinfo.ip_ipsec);

    break;

  case BGP_ENCAP_TYPE_MPLS_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE:

    rc = tlv_to_bgp_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode(

      stlv, &tto->bgpinfo.mpls_ipsec);

    break;

  case BGP_ENCAP_TYPE_IP_IN_IP:

    rc = tlv_to_bgp_encap_type_ip_in_ip(stlv, &tto->bgpinfo.ip_ip);

    break;

  case BGP_ENCAP_TYPE_VXLAN:

    rc = tlv_to_bgp_encap_type_vxlan(stlv, &tto->bgpinfo.vxlan);

    break;

  case BGP_ENCAP_TYPE_NVGRE:

    rc = tlv_to_bgp_encap_type_nvgre(stlv, &tto->bgpinfo.nvgre);

    break;

  case BGP_ENCAP_TYPE_MPLS:

    rc = tlv_to_bgp_encap_type_mpls(stlv, &tto->bgpinfo.mpls);

    break;

  case BGP_ENCAP_TYPE_MPLS_IN_GRE:

    rc = tlv_to_bgp_encap_type_mpls_in_gre(stlv,

                   &tto->bgpinfo.mpls_gre);

    break;

  case BGP_ENCAP_TYPE_VXLAN_GPE:

    rc = tlv_to_bgp_encap_type_vxlan_gpe(stlv,

                 &tto->bgpinfo.vxlan_gpe);

    break;

  case BGP_ENCAP_TYPE_MPLS_IN_UDP:

    rc = tlv_to_bgp_encap_type_mpls_in_udp(stlv,

                   &tto->bgpinfo.mpls_udp);

    break;

  case BGP_ENCAP_TYPE_PBB:

    rc = tlv_to_bgp_encap_type_pbb(stlv, &tto->bgpinfo.pbb);

    break;

  default:

    vnc_zlog_debug_verbose("%s: unknown tunnel type %d", __func__,

               attr->encap_tunneltype);

    rc = -1;

    break;

  }

  if (rc) {

    XFREE(MTYPE_RFAPI_UN_OPTION, uo);

  }

  return uo;

}

/***********************************************************************

 *      SUBTLV PRINT

 ***********************************************************************/

static void subtlv_print_encap_l2tpv3_over_ip(

  void *stream, int column_offset,

  struct bgp_tea_subtlv_encap_l2tpv3_over_ip *st)

{

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!st)

    return;

  fp(out, "%*s%s%s", column_offset, "", "SubTLV: Encap(L2TPv3 over IP)",

     vty_newline);

  fp(out, "%*s  SessionID: %d%s", column_offset, "", st->sessionid,

     vty_newline);

  fp(out, "%*s  Cookie: (length %d)%s", column_offset, "",

     st->cookie_length, vty_newline);

}

static void subtlv_print_encap_gre(void *stream, int column_offset,

           struct bgp_tea_subtlv_encap_gre_key *st)

{

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!st)

    return;

  fp(out, "%*s%s%s", column_offset, "", "SubTLV: Encap(GRE)",

     vty_newline);

  fp(out, "%*s  GRE key: %d (0x%x)%s", column_offset, "", st->gre_key,

     st->gre_key, vty_newline);

}

static void subtlv_print_encap_pbb(void *stream, int column_offset,

           struct bgp_tea_subtlv_encap_pbb *st)

{

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!st)

    return;

  fp(out, "%*s%s%s", column_offset, "", "SubTLV: Encap(PBB)",

     vty_newline);

  if (st->flag_isid) {

    fp(out, "%*s  ISID: %d (0x%x)%s", column_offset, "", st->isid,

       st->isid, vty_newline);

  }

  if (st->flag_vid) {

    fp(out, "%*s  VID: %d (0x%x)%s", column_offset, "", st->vid,

       st->vid, vty_newline);

  }

  fp(out, "%*s  MACADDR %02x:%02x:%02x:%02x:%02x:%02x%s", column_offset,

     "", st->macaddr[0], st->macaddr[1], st->macaddr[2], st->macaddr[3],

     st->macaddr[4], st->macaddr[5], vty_newline);

}

static void subtlv_print_proto_type(void *stream, int column_offset,

            struct bgp_tea_subtlv_proto_type *st)

{

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!st)

    return;

  fp(out, "%*s%s%s", column_offset, "", "SubTLV: Encap(Proto Type)",

     vty_newline);

  fp(out, "%*s  Proto %d (0x%x)%s", column_offset, "", st->proto,

     st->proto, vty_newline);

}

static void subtlv_print_color(void *stream, int column_offset,

             struct bgp_tea_subtlv_color *st)

{

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!st)

    return;

  fp(out, "%*s%s%s", column_offset, "", "SubTLV: Color", vty_newline);

  fp(out, "%*s  Color: %d (0x%x)", column_offset, "", st->color,

     st->color, vty_newline);

}

static void subtlv_print_ipsec_ta(void *stream, int column_offset,

          struct bgp_tea_subtlv_ipsec_ta *st)

{

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!st)

    return;

  fp(out, "%*s%s%s", column_offset, "", "SubTLV: IPSEC TA", vty_newline);

  fp(out, "%*s  Authenticator Type: %d (0x%x)", column_offset, "",

     st->authenticator_type, st->authenticator_type, vty_newline);

  fp(out, "%*s  Authenticator: (length %d)", column_offset, "",

     st->authenticator_length, vty_newline);

}

/***********************************************************************

 *      TLV PRINT

 ***********************************************************************/

static void

print_encap_type_l2tpv3overip(void *stream, int column_offset,

            struct bgp_encap_type_l2tpv3_over_ip *bet)

{

  const char *type = "L2TPv3 over IP";

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!bet)

    return;

  fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);

  subtlv_print_encap_l2tpv3_over_ip(stream, column_offset + 2,

            &bet->st_encap);

  subtlv_print_proto_type(stream, column_offset + 2, &bet->st_proto);

  subtlv_print_color(stream, column_offset + 2, &bet->st_color);

}

static void print_encap_type_gre(void *stream, int column_offset,

         struct bgp_encap_type_gre *bet)

{

  const char *type = "GRE";

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!bet)

    return;

  fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);

  subtlv_print_encap_gre(stream, column_offset + 2, &bet->st_encap);

  subtlv_print_proto_type(stream, column_offset + 2, &bet->st_proto);

  subtlv_print_color(stream, column_offset + 2, &bet->st_color);

}

static void print_encap_type_ip_in_ip(void *stream, int column_offset,

              struct bgp_encap_type_ip_in_ip *bet)

{

  const char *type = "IP in IP";

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!bet)

    return;

  fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);

  subtlv_print_proto_type(stream, column_offset + 2, &bet->st_proto);

  subtlv_print_color(stream, column_offset + 2, &bet->st_color);

}

static void print_encap_type_transmit_tunnel_endpoint(

  void *stream, int column_offset,

  struct bgp_encap_type_transmit_tunnel_endpoint *bet)

{

  const char *type = "Transmit Tunnel Endpoint";

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!bet)

    return;

  fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);

  /* no subtlvs for this type */

}

static void print_encap_type_ipsec_in_tunnel_mode(

  void *stream, int column_offset,

  struct bgp_encap_type_ipsec_in_tunnel_mode *bet)

{

  const char *type = "IPSEC in Tunnel mode";

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!bet)

    return;

  fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);

  subtlv_print_ipsec_ta(stream, column_offset + 2, &bet->st_ipsec_ta);

}

static void print_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode(

  void *stream, int column_offset,

  struct bgp_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode *bet)

{

  const char *type = "IP in IP Tunnel with IPSEC transport mode";

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!bet)

    return;

  fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);

  subtlv_print_ipsec_ta(stream, column_offset + 2, &bet->st_ipsec_ta);

}

static void print_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode(

  void *stream, int column_offset,

  struct bgp_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode *bet)

{

  const char *type = "MPLS in IP Tunnel with IPSEC transport mode";

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!bet)

    return;

  fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);

  subtlv_print_ipsec_ta(stream, column_offset + 2, &bet->st_ipsec_ta);

}

static void print_encap_type_pbb(void *stream, int column_offset,

         struct bgp_encap_type_pbb *bet)

{

  const char *type = "PBB";

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!bet)

    return;

  fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);

  subtlv_print_encap_pbb(stream, column_offset + 2, &bet->st_encap);

}

static void print_encap_type_vxlan(void *stream, int column_offset,

           struct bgp_encap_type_vxlan *bet)

{

  const char *type = "VXLAN";

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!bet)

    return;

  fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);

  /* no subtlvs for this type */

}

static void print_encap_type_nvgre(void *stream, int column_offset,

           struct bgp_encap_type_nvgre *bet)

{

  const char *type = "NVGRE";

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!bet)

    return;

  fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);

  /* no subtlvs for this type */

}

static void print_encap_type_mpls(void *stream, int column_offset,

          struct bgp_encap_type_mpls *bet)

{

  const char *type = "MPLS";

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!bet)

    return;

  fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);

  /* no subtlvs for this type */

}

static void print_encap_type_mpls_in_gre(void *stream, int column_offset,

           struct bgp_encap_type_mpls_in_gre *bet)

{

  const char *type = "MPLS in GRE";

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!bet)

    return;

  fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);

  /* no subtlvs for this type */

}

static void print_encap_type_vxlan_gpe(void *stream, int column_offset,

               struct bgp_encap_type_vxlan_gpe *bet)

{

  const char *type = "VXLAN GPE";

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!bet)

    return;

  fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);

  /* no subtlvs for this type */

}

static void print_encap_type_mpls_in_udp(void *stream, int column_offset,

           struct bgp_encap_type_mpls_in_udp *bet)

{

  const char *type = "MPLS in UDP";

  int (*fp)(void *, const char *, ...);

  struct vty *vty;

  void *out;

  const char *vty_newline;

  if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)

    return;

  if (!bet)

    return;

  fp(out, "%*sTEA type %s%s", column_offset, "", type, vty_newline);

  /* no subtlvs for this type */

}

void rfapi_print_tunneltype_option(void *stream, int column_offset,

           struct rfapi_tunneltype_option *tto)

{

  switch (tto->type) {

  case BGP_ENCAP_TYPE_L2TPV3_OVER_IP:

    print_encap_type_l2tpv3overip(stream, column_offset,

                &tto->bgpinfo.l2tpv3_ip);

    break;

  case BGP_ENCAP_TYPE_GRE:

    print_encap_type_gre(stream, column_offset, &tto->bgpinfo.gre);

    break;

  case BGP_ENCAP_TYPE_TRANSMIT_TUNNEL_ENDPOINT:

    print_encap_type_transmit_tunnel_endpoint(

      stream, column_offset,

      &tto->bgpinfo.transmit_tunnel_endpoint);

    break;

  case BGP_ENCAP_TYPE_IPSEC_IN_TUNNEL_MODE:

    print_encap_type_ipsec_in_tunnel_mode(

      stream, column_offset, &tto->bgpinfo.ipsec_tunnel);

    break;

  case BGP_ENCAP_TYPE_IP_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE:

    print_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode(

      stream, column_offset, &tto->bgpinfo.ip_ipsec);

    break;

  case BGP_ENCAP_TYPE_MPLS_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE:

    print_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode(

      stream, column_offset, &tto->bgpinfo.mpls_ipsec);

    break;

  case BGP_ENCAP_TYPE_IP_IN_IP:

    print_encap_type_ip_in_ip(stream, column_offset,

            &tto->bgpinfo.ip_ip);

    break;

  case BGP_ENCAP_TYPE_VXLAN:

    print_encap_type_vxlan(stream, column_offset,

               &tto->bgpinfo.vxlan);

    break;

  case BGP_ENCAP_TYPE_NVGRE:

    print_encap_type_nvgre(stream, column_offset,

               &tto->bgpinfo.nvgre);

    break;

  case BGP_ENCAP_TYPE_MPLS:

    print_encap_type_mpls(stream, column_offset,

              &tto->bgpinfo.mpls);

    break;

  case BGP_ENCAP_TYPE_MPLS_IN_GRE:

    print_encap_type_mpls_in_gre(stream, column_offset,

               &tto->bgpinfo.mpls_gre);

    break;

  case BGP_ENCAP_TYPE_VXLAN_GPE:

    print_encap_type_vxlan_gpe(stream, column_offset,

             &tto->bgpinfo.vxlan_gpe);

    break;

  case BGP_ENCAP_TYPE_MPLS_IN_UDP:

    print_encap_type_mpls_in_udp(stream, column_offset,

               &tto->bgpinfo.mpls_udp);

    break;

  case BGP_ENCAP_TYPE_PBB:

    print_encap_type_pbb(stream, column_offset, &tto->bgpinfo.pbb);

    break;

  case BGP_ENCAP_TYPE_RESERVED:

    assert(!"Cannot process BGP_ENCAP_TYPE_RESERVED");

  }

}