bgpd/bgp_encap_tlv.c

   1 /*
   2  * Copyright 2015, 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
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  *
  18  */
  19
  20 #include <zebra.h>
  21
  22 #include "memory.h"
  23 #include "prefix.h"
  24 #include "vty.h"
  25 #include "filter.h"
  26
  27 #include "bgpd.h"
  28 #include "bgp_attr.h"
  29
  30 #include "bgp_encap_types.h"
  31 #include "bgp_encap_tlv.h"
  32
  33 /***********************************************************************
  34  *                      SUBTLV ENCODE
  35  ***********************************************************************/
  36
  37 /* rfc5512 4.1 */
  38 static struct bgp_attr_encap_subtlv *
  39 subtlv_encode_encap_l2tpv3_over_ip(
  40     struct bgp_tea_subtlv_encap_l2tpv3_over_ip  *st)
  41 {
  42     struct bgp_attr_encap_subtlv        *new;
  43     uint8_t                             *p;
  44     int                                 total = 4 + st->cookie_length;
  45
  46     /* sanity check */
  47     assert(st->cookie_length <= sizeof(st->cookie));
  48     assert(total <= 0xff);
  49
  50     new = XCALLOC(MTYPE_ENCAP_TLV, sizeof(struct bgp_attr_encap_subtlv) - 1 + total);
  51     assert(new);
  52     new->type = BGP_ENCAP_SUBTLV_TYPE_ENCAPSULATION;
  53     new->length = total;
  54     p = new->value;
  55
  56     *p++ = (st->sessionid & 0xff000000) >> 24;
  57     *p++ = (st->sessionid & 0xff0000) >> 16;
  58     *p++ = (st->sessionid & 0xff00) >> 8;
  59     *p++ = (st->sessionid & 0xff);
  60     memcpy(p, st->cookie, st->cookie_length);
  61     return new;
  62 }
  63
  64 /* rfc5512 4.1 */
  65 static struct bgp_attr_encap_subtlv *
  66 subtlv_encode_encap_gre(
  67     struct bgp_tea_subtlv_encap_gre_key *st)
  68 {
  69     struct bgp_attr_encap_subtlv        *new;
  70     uint8_t                             *p;
  71     int                                 total = 4;
  72
  73     assert(total <= 0xff);
  74
  75     new = XCALLOC(MTYPE_ENCAP_TLV, sizeof(struct bgp_attr_encap_subtlv) - 1 + total);
  76     assert(new);
  77     new->type = BGP_ENCAP_SUBTLV_TYPE_ENCAPSULATION;
  78     new->length = total;
  79     p = new->value;
  80
  81     *p++ = (st->gre_key & 0xff000000) >> 24;
  82     *p++ = (st->gre_key & 0xff0000) >> 16;
  83     *p++ = (st->gre_key & 0xff00) >> 8;
  84     *p++ = (st->gre_key & 0xff);
  85     return new;
  86 }
  87
  88 static struct bgp_attr_encap_subtlv *
  89 subtlv_encode_encap_pbb(
  90     struct bgp_tea_subtlv_encap_pbb     *st)
  91 {
  92     struct bgp_attr_encap_subtlv        *new;
  93     uint8_t                             *p;
  94     int         total = 1 + 3 + 6 + 2;  /* flags + isid + madaddr + vid */
  95
  96     assert(total <= 0xff);
  97
  98     new = XCALLOC(MTYPE_ENCAP_TLV, sizeof(struct bgp_attr_encap_subtlv) - 1 + total);
  99     assert(new);
 100     new->type = BGP_ENCAP_SUBTLV_TYPE_ENCAPSULATION;
 101     new->length = total;
 102     p = new->value;
 103
 104     *p++ = (st->flag_isid? 0x80: 0) |
 105              (st->flag_vid? 0x40: 0) |
 106              0;
 107     if (st->flag_isid) {
 108         *p = (st->isid & 0xff0000) >> 16;
 109         *(p+1) = (st->isid & 0xff00) >> 8;
 110         *(p+2) = (st->isid & 0xff);
 111     }
 112     p += 3;
 113     memcpy(p, st->macaddr, 6);
 114     p += 6;
 115     if (st->flag_vid) {
 116         *p++ = (st->vid & 0xf00) >> 8;
 117         *p++ = st->vid & 0xff;
 118     }
 119     return new;
 120 }
 121
 122 /* rfc5512 4.2 */
 123 static struct bgp_attr_encap_subtlv *
 124 subtlv_encode_proto_type(
 125     struct bgp_tea_subtlv_proto_type    *st)
 126 {
 127     struct bgp_attr_encap_subtlv        *new;
 128     uint8_t                             *p;
 129     int total = 2;
 130
 131     assert(total <= 0xff);
 132
 133     new = XCALLOC(MTYPE_ENCAP_TLV, sizeof(struct bgp_attr_encap_subtlv) - 1 + total);
 134     assert(new);
 135     new->type = BGP_ENCAP_SUBTLV_TYPE_PROTO_TYPE;
 136     new->length = total;
 137     p = new->value;
 138
 139     *p++ = (st->proto & 0xff00) >> 8;
 140     *p++ = (st->proto & 0xff);
 141     return new;
 142 }
 143
 144 /* rfc5512 4.3 */
 145 static struct bgp_attr_encap_subtlv *
 146 subtlv_encode_color(
 147     struct bgp_tea_subtlv_color *st)
 148 {
 149     struct bgp_attr_encap_subtlv        *new;
 150     uint8_t                             *p;
 151     int total = 8;
 152
 153     assert(total <= 0xff);
 154
 155     new = XCALLOC(MTYPE_ENCAP_TLV, sizeof(struct bgp_attr_encap_subtlv) - 1 + total);
 156     assert(new);
 157     new->type = BGP_ENCAP_SUBTLV_TYPE_COLOR;
 158     new->length = total;
 159     p = new->value;
 160
 161     *p++ = 0x03;                                /* transitive*/
 162     *p++ = 0x0b;
 163     *p++ = 0;                                   /* reserved */
 164     *p++ = 0;                                   /* reserved */
 165
 166     *p++ = (st->color & 0xff000000) >> 24;
 167     *p++ = (st->color & 0xff0000) >> 16;
 168     *p++ = (st->color & 0xff00) >> 8;
 169     *p++ = (st->color & 0xff);
 170
 171     return new;
 172 }
 173
 174 /* rfc 5566 4. */
 175 static struct bgp_attr_encap_subtlv *
 176 subtlv_encode_ipsec_ta(
 177     struct bgp_tea_subtlv_ipsec_ta      *st)
 178 {
 179     struct bgp_attr_encap_subtlv        *new;
 180     uint8_t                             *p;
 181     int total = 2 + st->authenticator_length;
 182
 183     /* sanity check */
 184     assert(st->authenticator_length <= sizeof(st->value));
 185     assert(total <= 0xff);
 186
 187     new = XCALLOC(MTYPE_ENCAP_TLV, sizeof(struct bgp_attr_encap_subtlv) - 1 + total);
 188     assert(new);
 189     new->type = BGP_ENCAP_SUBTLV_TYPE_IPSEC_TA;
 190     new->length = total;
 191     p = new->value;
 192
 193     *p++ = (st->authenticator_type & 0xff00) >> 8;
 194     *p++ = st->authenticator_type & 0xff;
 195     memcpy(p, st->value, st->authenticator_length);
 196     return new;
 197 }
 198
 199 /* draft-rosen-idr-tunnel-encaps 2.1 */
 200 static struct bgp_attr_encap_subtlv *
 201 subtlv_encode_remote_endpoint(
 202     struct bgp_tea_subtlv_remote_endpoint       *st)
 203 {
 204     struct bgp_attr_encap_subtlv        *new;
 205     uint8_t                             *p;
 206
 207     int total = (st->family==AF_INET?8:20);
 208
 209     assert(total <= 0xff);
 210
 211     new = XCALLOC(MTYPE_ENCAP_TLV, sizeof(struct bgp_attr_encap_subtlv) - 1 + total);
 212     assert(new);
 213     new->type = BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT;
 214     new->length = total;
 215     p = new->value;
 216     if (st->family == AF_INET) {
 217         memcpy (p, &(st->ip_address.v4.s_addr), 4);
 218         p+=4;
 219     } else {
 220         assert (st->family == AF_INET6);
 221         memcpy (p, &(st->ip_address.v6.s6_addr), 16);
 222         p+=16;
 223     }
 224     memcpy (p, &(st->as4), 4);
 225     return new;
 226 }
 227
 228 /***********************************************************************
 229  *              TUNNEL TYPE-SPECIFIC TLV ENCODE
 230  ***********************************************************************/
 231
 232 /*
 233  * requires "extra" and "last" to be defined in caller
 234  */
 235 #define ENC_SUBTLV(flag, function, field) do {\
 236     struct bgp_attr_encap_subtlv        *new;\
 237     if (CHECK_FLAG(bet->valid_subtlvs, (flag))) {\
 238         new = function(&bet->field);\
 239         if (last) {\
 240             last->next = new;\
 241         } else {\
 242             extra->encap_subtlvs = new;\
 243         }\
 244         last = new;\
 245     }\
 246 } while (0)
 247
 248 void
 249 bgp_encap_type_l2tpv3overip_to_tlv(
 250     struct bgp_encap_type_l2tpv3_over_ip        *bet,   /* input structure */
 251     struct attr                                 *attr)
 252 {
 253     struct attr_extra                   *extra = bgp_attr_extra_get(attr);
 254     struct bgp_attr_encap_subtlv        *last;
 255
 256     /* advance to last subtlv */
 257     for (last = extra->encap_subtlvs; last && last->next; last = last->next);
 258
 259     extra->encap_tunneltype = BGP_ENCAP_TYPE_L2TPV3_OVER_IP;
 260
 261     assert(CHECK_FLAG(bet->valid_subtlvs, BGP_TEA_SUBTLV_ENCAP));
 262
 263     ENC_SUBTLV(BGP_TEA_SUBTLV_ENCAP, subtlv_encode_encap_l2tpv3_over_ip, st_encap);
 264     ENC_SUBTLV(BGP_TEA_SUBTLV_PROTO_TYPE, subtlv_encode_proto_type, st_proto);
 265     ENC_SUBTLV(BGP_TEA_SUBTLV_COLOR, subtlv_encode_color, st_color);
 266     ENC_SUBTLV(BGP_TEA_SUBTLV_REMOTE_ENDPOINT, subtlv_encode_remote_endpoint, st_endpoint);
 267 }
 268
 269 void
 270 bgp_encap_type_gre_to_tlv(
 271     struct bgp_encap_type_gre   *bet,   /* input structure */
 272     struct attr                 *attr)
 273 {
 274     struct attr_extra                   *extra = bgp_attr_extra_get(attr);
 275     struct bgp_attr_encap_subtlv        *last;
 276
 277     /* advance to last subtlv */
 278     for (last = extra->encap_subtlvs; last && last->next; last = last->next);
 279
 280     extra->encap_tunneltype = BGP_ENCAP_TYPE_GRE;
 281
 282     ENC_SUBTLV(BGP_TEA_SUBTLV_ENCAP, subtlv_encode_encap_gre, st_encap);
 283     ENC_SUBTLV(BGP_TEA_SUBTLV_PROTO_TYPE, subtlv_encode_proto_type, st_proto);
 284     ENC_SUBTLV(BGP_TEA_SUBTLV_COLOR, subtlv_encode_color, st_color);
 285     ENC_SUBTLV(BGP_TEA_SUBTLV_REMOTE_ENDPOINT, subtlv_encode_remote_endpoint, st_endpoint);
 286 }
 287
 288 void
 289 bgp_encap_type_ip_in_ip_to_tlv(
 290     struct bgp_encap_type_ip_in_ip      *bet,   /* input structure */
 291     struct attr                         *attr)
 292 {
 293     struct attr_extra                   *extra = bgp_attr_extra_get(attr);
 294     struct bgp_attr_encap_subtlv        *last;
 295
 296     /* advance to last subtlv */
 297     for (last = extra->encap_subtlvs; last && last->next; last = last->next);
 298
 299     extra->encap_tunneltype = BGP_ENCAP_TYPE_IP_IN_IP;
 300
 301     ENC_SUBTLV(BGP_TEA_SUBTLV_PROTO_TYPE, subtlv_encode_proto_type, st_proto);
 302     ENC_SUBTLV(BGP_TEA_SUBTLV_COLOR, subtlv_encode_color, st_color);
 303     ENC_SUBTLV(BGP_TEA_SUBTLV_REMOTE_ENDPOINT, subtlv_encode_remote_endpoint, st_endpoint);
 304 }
 305
 306 void
 307 bgp_encap_type_transmit_tunnel_endpoint(
 308     struct bgp_encap_type_transmit_tunnel_endpoint      *bet,   /* input structure */
 309     struct attr                         *attr)
 310 {
 311     struct attr_extra                   *extra = bgp_attr_extra_get(attr);
 312     struct bgp_attr_encap_subtlv        *last;
 313
 314     /* advance to last subtlv */
 315     for (last = extra->encap_subtlvs; last && last->next; last = last->next);
 316
 317     extra->encap_tunneltype = BGP_ENCAP_TYPE_TRANSMIT_TUNNEL_ENDPOINT;
 318
 319     /* no subtlvs for this type */
 320 }
 321
 322 void
 323 bgp_encap_type_ipsec_in_tunnel_mode_to_tlv(
 324     struct bgp_encap_type_ipsec_in_tunnel_mode  *bet,   /* input structure */
 325     struct attr                         *attr)
 326 {
 327     struct attr_extra                   *extra = bgp_attr_extra_get(attr);
 328     struct bgp_attr_encap_subtlv        *last;
 329
 330     /* advance to last subtlv */
 331     for (last = extra->encap_subtlvs; last && last->next; last = last->next);
 332
 333     extra->encap_tunneltype = BGP_ENCAP_TYPE_IPSEC_IN_TUNNEL_MODE;
 334
 335     ENC_SUBTLV(BGP_TEA_SUBTLV_IPSEC_TA, subtlv_encode_ipsec_ta, st_ipsec_ta);
 336 }
 337
 338 void
 339 bgp_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode_to_tlv(
 340     struct bgp_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode     *bet,   /* input structure */
 341     struct attr                         *attr)
 342 {
 343     struct attr_extra                   *extra = bgp_attr_extra_get(attr);
 344     struct bgp_attr_encap_subtlv        *last;
 345
 346     /* advance to last subtlv */
 347     for (last = extra->encap_subtlvs; last && last->next; last = last->next);
 348
 349     extra->encap_tunneltype = BGP_ENCAP_TYPE_IP_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE;
 350
 351     ENC_SUBTLV(BGP_TEA_SUBTLV_IPSEC_TA, subtlv_encode_ipsec_ta, st_ipsec_ta);
 352 }
 353
 354 void
 355 bgp_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode_to_tlv(
 356     struct bgp_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode   *bet,   /* input structure */
 357     struct attr                         *attr)
 358 {
 359     struct attr_extra                   *extra = bgp_attr_extra_get(attr);
 360     struct bgp_attr_encap_subtlv        *last;
 361
 362     /* advance to last subtlv */
 363     for (last = extra->encap_subtlvs; last && last->next; last = last->next);
 364
 365     extra->encap_tunneltype = BGP_ENCAP_TYPE_MPLS_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE;
 366
 367     ENC_SUBTLV(BGP_TEA_SUBTLV_IPSEC_TA, subtlv_encode_ipsec_ta, st_ipsec_ta);
 368 }
 369
 370 void
 371 bgp_encap_type_pbb_to_tlv(
 372     struct bgp_encap_type_pbb   *bet,   /* input structure */
 373     struct attr                         *attr)
 374 {
 375     struct attr_extra                   *extra = bgp_attr_extra_get(attr);
 376     struct bgp_attr_encap_subtlv        *last;
 377
 378     /* advance to last subtlv */
 379     for (last = extra->encap_subtlvs; last && last->next; last = last->next);
 380
 381     extra->encap_tunneltype = BGP_ENCAP_TYPE_PBB;
 382
 383     assert(CHECK_FLAG(bet->valid_subtlvs, BGP_TEA_SUBTLV_ENCAP));
 384     ENC_SUBTLV(BGP_TEA_SUBTLV_ENCAP, subtlv_encode_encap_pbb, st_encap);
 385 }
 386
 387 void
 388 bgp_encap_type_vxlan_to_tlv(
 389     struct bgp_encap_type_vxlan *bet,   /* input structure */
 390     struct attr                         *attr)
 391 {
 392     struct attr_extra                   *extra = bgp_attr_extra_get(attr);
 393
 394     extra->encap_tunneltype = BGP_ENCAP_TYPE_VXLAN;
 395 }
 396
 397 void
 398 bgp_encap_type_nvgre_to_tlv(
 399     struct bgp_encap_type_nvgre *bet,   /* input structure */
 400     struct attr                         *attr)
 401 {
 402     struct attr_extra                   *extra = bgp_attr_extra_get(attr);
 403
 404     extra->encap_tunneltype = BGP_ENCAP_TYPE_NVGRE;
 405 }
 406
 407 void
 408 bgp_encap_type_mpls_to_tlv(
 409     struct bgp_encap_type_mpls  *bet,   /* input structure */
 410     struct attr                         *attr)
 411 {
 412     return;                     /* no encap attribute for MPLS */
 413 }
 414
 415 void
 416 bgp_encap_type_mpls_in_gre_to_tlv(
 417     struct bgp_encap_type_mpls_in_gre   *bet,   /* input structure */
 418     struct attr                         *attr)
 419 {
 420     struct attr_extra                   *extra = bgp_attr_extra_get(attr);
 421
 422     extra->encap_tunneltype = BGP_ENCAP_TYPE_MPLS_IN_GRE;
 423 }
 424
 425 void
 426 bgp_encap_type_vxlan_gpe_to_tlv(
 427     struct bgp_encap_type_vxlan_gpe     *bet,   /* input structure */
 428     struct attr                         *attr)
 429 {
 430     struct attr_extra                   *extra = bgp_attr_extra_get(attr);
 431
 432     extra->encap_tunneltype = BGP_ENCAP_TYPE_VXLAN_GPE;
 433 }
 434
 435 void
 436 bgp_encap_type_mpls_in_udp_to_tlv(
 437     struct bgp_encap_type_mpls_in_udp   *bet,   /* input structure */
 438     struct attr                         *attr)
 439 {
 440     struct attr_extra                   *extra = bgp_attr_extra_get(attr);
 441
 442     extra->encap_tunneltype = BGP_ENCAP_TYPE_MPLS_IN_UDP;
 443 }
 444
 445
 446 /***********************************************************************
 447  *                      SUBTLV DECODE
 448  ***********************************************************************/
 449 /* rfc5512 4.1 */
 450 static int
 451 subtlv_decode_encap_l2tpv3_over_ip(
 452     struct bgp_attr_encap_subtlv                *subtlv,
 453     struct bgp_tea_subtlv_encap_l2tpv3_over_ip  *st)
 454 {
 455     if (subtlv->length < 4) {
 456         zlog_debug("%s, subtlv length %d is less than 4",
 457             __func__, subtlv->length);
 458         return -1;
 459     }
 460
 461     st->sessionid = (subtlv->value[0] << 24) |
 462                     (subtlv->value[1] << 16) |
 463                     (subtlv->value[2] << 8)  |
 464                     subtlv->value[3];
 465     st->cookie_length = subtlv->length - 4;
 466     if (st->cookie_length > sizeof(st->cookie)) {
 467         zlog_debug("%s, subtlv length %d is greater than %d",
 468             __func__, st->cookie_length, (int)sizeof(st->cookie));
 469         return -1;
 470     }
 471     memcpy(st->cookie, subtlv->value + 4, st->cookie_length);
 472     return 0;
 473 }
 474
 475 /* rfc5512 4.1 */
 476 static int
 477 subtlv_decode_encap_gre(
 478     struct bgp_attr_encap_subtlv        *subtlv,
 479     struct bgp_tea_subtlv_encap_gre_key *st)
 480 {
 481     if (subtlv->length != 4) {
 482         zlog_debug("%s, subtlv length %d does not equal 4",
 483             __func__, subtlv->length);
 484         return -1;
 485     }
 486     st->gre_key = (subtlv->value[0] << 24) |
 487                     (subtlv->value[1] << 16) |
 488                     (subtlv->value[2] << 8)  |
 489                     subtlv->value[3];
 490     return 0;
 491 }
 492
 493 static int
 494 subtlv_decode_encap_pbb(
 495     struct bgp_attr_encap_subtlv        *subtlv,
 496     struct bgp_tea_subtlv_encap_pbb     *st)
 497 {
 498     if (subtlv->length != 1 + 3 + 6 + 2) {
 499         zlog_debug("%s, subtlv length %d does not equal %d",
 500             __func__, subtlv->length, 1 + 3 + 6 + 2);
 501         return -1;
 502     }
 503     if (subtlv->value[0] & 0x80) {
 504         st->flag_isid = 1;
 505         st->isid = (subtlv->value[1] << 16) |
 506                     (subtlv->value[2] << 8) |
 507                     subtlv->value[3];
 508     }
 509     if (subtlv->value[0] & 0x40) {
 510         st->flag_vid  = 1;
 511         st->vid = ((subtlv->value[10] & 0x0f) << 8) | subtlv->value[11];
 512     }
 513     memcpy(st->macaddr, subtlv->value + 4, 6);
 514     return 0;
 515 }
 516
 517 /* rfc5512 4.2 */
 518 static int
 519 subtlv_decode_proto_type(
 520     struct bgp_attr_encap_subtlv        *subtlv,
 521     struct bgp_tea_subtlv_proto_type    *st)
 522 {
 523     if (subtlv->length != 2) {
 524         zlog_debug("%s, subtlv length %d does not equal 2",
 525             __func__, subtlv->length);
 526         return -1;
 527     }
 528     st->proto = (subtlv->value[0] << 8) | subtlv->value[1];
 529     return 0;
 530 }
 531
 532 /* rfc5512 4.3 */
 533 static int
 534 subtlv_decode_color(
 535     struct bgp_attr_encap_subtlv        *subtlv,
 536     struct bgp_tea_subtlv_color         *st)
 537 {
 538     if (subtlv->length != 8) {
 539         zlog_debug("%s, subtlv length %d does not equal 8",
 540             __func__, subtlv->length);
 541         return -1;
 542     }
 543     if ((subtlv->value[0] != 0x03) ||
 544         (subtlv->value[1] != 0x0b) ||
 545         (subtlv->value[2] != 0)    ||
 546         (subtlv->value[3] != 0)) {
 547         zlog_debug("%s, subtlv value 1st 4 bytes are not 0x030b0000", __func__);
 548         return -1;
 549     }
 550     st->color = (subtlv->value[4] << 24) |
 551                 (subtlv->value[5] << 16) |
 552                 (subtlv->value[6] << 8)  |
 553                 subtlv->value[7];
 554     return 0;
 555 }
 556
 557 /* rfc 5566 4. */
 558 static int
 559 subtlv_decode_ipsec_ta(
 560     struct bgp_attr_encap_subtlv        *subtlv,
 561     struct bgp_tea_subtlv_ipsec_ta      *st)
 562 {
 563     st->authenticator_length = subtlv->length - 2;
 564     if (st->authenticator_length > sizeof(st->value)) {
 565         zlog_debug("%s, authenticator length %d exceeds storage maximum %d",
 566             __func__, st->authenticator_length, (int)sizeof(st->value));
 567         return -1;
 568     }
 569     st->authenticator_type = (subtlv->value[0] << 8) | subtlv->value[1];
 570     memcpy(st->value, subtlv->value + 2,  st->authenticator_length);
 571     return 0;
 572 }
 573
 574 /* draft-rosen-idr-tunnel-encaps 2.1 */
 575 static int
 576 subtlv_decode_remote_endpoint(
 577     struct bgp_attr_encap_subtlv          *subtlv,
 578     struct bgp_tea_subtlv_remote_endpoint *st)
 579 {
 580    int i;
 581    if (subtlv->length != 8 && subtlv->length != 20 ) {
 582         zlog_debug("%s, subtlv length %d does not equal 8 or 20",
 583             __func__, subtlv->length);
 584         return -1;
 585     }
 586     if (subtlv->length == 8) {
 587         st->family = AF_INET;
 588         st->ip_address.v4.s_addr = ((subtlv->value[0] << 24) |
 589                                     (subtlv->value[1] << 16) |
 590                                     (subtlv->value[2] << 8)  |
 591                                     subtlv->value[3]);
 592     } else {
 593         st->family = AF_INET6;
 594         memcpy (&(st->ip_address.v6.s6_addr), subtlv->value, 16);
 595     }
 596     i = subtlv->length - 4;
 597     st->as4 = ((subtlv->value[i] << 24) |
 598                (subtlv->value[i+1] << 16) |
 599                (subtlv->value[i+2] << 8)  |
 600                subtlv->value[i+3]);
 601     return 0;
 602 }
 603
 604 /***********************************************************************
 605  *              TUNNEL TYPE-SPECIFIC TLV DECODE
 606  ***********************************************************************/
 607
 608 int
 609 tlv_to_bgp_encap_type_l2tpv3overip(
 610     struct bgp_attr_encap_subtlv                *stlv,  /* subtlv chain */
 611     struct bgp_encap_type_l2tpv3_over_ip        *bet)   /* caller-allocated */
 612 {
 613     struct bgp_attr_encap_subtlv                *st;
 614     int                                         rc = 0;
 615
 616     for (st = stlv; st; st = st->next) {
 617         switch (st->type) {
 618             case BGP_ENCAP_SUBTLV_TYPE_ENCAPSULATION:
 619                 rc |= subtlv_decode_encap_l2tpv3_over_ip(st, &bet->st_encap);
 620                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_ENCAP);
 621                 break;
 622
 623             case BGP_ENCAP_SUBTLV_TYPE_PROTO_TYPE:
 624                 rc |= subtlv_decode_proto_type(st, &bet->st_proto);
 625                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_PROTO_TYPE);
 626                 break;
 627
 628             case BGP_ENCAP_SUBTLV_TYPE_COLOR:
 629                 rc |= subtlv_decode_color(st, &bet->st_color);
 630                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_COLOR);
 631                 break;
 632
 633             case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT:
 634                 rc |= subtlv_decode_remote_endpoint(st, &bet->st_endpoint);
 635                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_REMOTE_ENDPOINT);
 636                 break;
 637
 638             default:
 639                 zlog_debug("%s: unexpected subtlv type %d", __func__, st->type);
 640                 rc |= -1;
 641                 break;
 642         }
 643     }
 644     return rc;
 645 }
 646
 647 int
 648 tlv_to_bgp_encap_type_gre(
 649     struct bgp_attr_encap_subtlv        *stlv,  /* subtlv chain */
 650     struct bgp_encap_type_gre           *bet)   /* caller-allocated */
 651 {
 652     struct bgp_attr_encap_subtlv                *st;
 653     int                                         rc = 0;
 654
 655     for (st = stlv; st; st = st->next) {
 656         switch (st->type) {
 657             case BGP_ENCAP_SUBTLV_TYPE_ENCAPSULATION:
 658                 rc |= subtlv_decode_encap_gre(st, &bet->st_encap);
 659                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_ENCAP);
 660                 break;
 661
 662             case BGP_ENCAP_SUBTLV_TYPE_PROTO_TYPE:
 663                 rc |= subtlv_decode_proto_type(st, &bet->st_proto);
 664                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_PROTO_TYPE);
 665                 break;
 666
 667             case BGP_ENCAP_SUBTLV_TYPE_COLOR:
 668                 rc |= subtlv_decode_color(st, &bet->st_color);
 669                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_COLOR);
 670                 break;
 671
 672             case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT:
 673                 rc |= subtlv_decode_remote_endpoint(st, &bet->st_endpoint);
 674                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_REMOTE_ENDPOINT);
 675                 break;
 676
 677             default:
 678                 zlog_debug("%s: unexpected subtlv type %d", __func__, st->type);
 679                 rc |= -1;
 680                 break;
 681         }
 682     }
 683     return rc;
 684 }
 685
 686 int
 687 tlv_to_bgp_encap_type_ip_in_ip(
 688     struct bgp_attr_encap_subtlv        *stlv,  /* subtlv chain */
 689     struct bgp_encap_type_ip_in_ip      *bet)   /* caller-allocated */
 690 {
 691     struct bgp_attr_encap_subtlv                *st;
 692     int                                         rc = 0;
 693
 694     for (st = stlv; st; st = st->next) {
 695         switch (st->type) {
 696             case BGP_ENCAP_SUBTLV_TYPE_PROTO_TYPE:
 697                 rc |= subtlv_decode_proto_type(st, &bet->st_proto);
 698                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_PROTO_TYPE);
 699                 break;
 700
 701             case BGP_ENCAP_SUBTLV_TYPE_COLOR:
 702                 rc |= subtlv_decode_color(st, &bet->st_color);
 703                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_COLOR);
 704                 break;
 705
 706             case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT:
 707                 rc |= subtlv_decode_remote_endpoint(st, &bet->st_endpoint);
 708                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_REMOTE_ENDPOINT);
 709                 break;
 710
 711             default:
 712                 zlog_debug("%s: unexpected subtlv type %d", __func__, st->type);
 713                 rc |= -1;
 714                 break;
 715         }
 716     }
 717     return rc;
 718 }
 719
 720 int
 721 tlv_to_bgp_encap_type_transmit_tunnel_endpoint(
 722     struct bgp_attr_encap_subtlv                        *stlv,
 723     struct bgp_encap_type_transmit_tunnel_endpoint      *bet)
 724 {
 725     struct bgp_attr_encap_subtlv                *st;
 726     int                                         rc = 0;
 727
 728     for (st = stlv; st; st = st->next) {
 729         switch (st->type) {
 730
 731             case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT:
 732                 rc |= subtlv_decode_remote_endpoint(st, &bet->st_endpoint);
 733                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_REMOTE_ENDPOINT);
 734                 break;
 735
 736             default:
 737                 zlog_debug("%s: unexpected subtlv type %d", __func__, st->type);
 738                 rc |= -1;
 739                 break;
 740         }
 741     }
 742     return rc;
 743 }
 744
 745 int
 746 tlv_to_bgp_encap_type_ipsec_in_tunnel_mode(
 747     struct bgp_attr_encap_subtlv                *stlv,  /* subtlv chain */
 748     struct bgp_encap_type_ipsec_in_tunnel_mode  *bet)   /* caller-allocated */
 749 {
 750     struct bgp_attr_encap_subtlv                *st;
 751     int                                         rc = 0;
 752
 753     for (st = stlv; st; st = st->next) {
 754         switch (st->type) {
 755             case BGP_ENCAP_SUBTLV_TYPE_IPSEC_TA:
 756                 rc |= subtlv_decode_ipsec_ta(st, &bet->st_ipsec_ta);
 757                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_IPSEC_TA);
 758                 break;
 759
 760             case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT:
 761                 rc |= subtlv_decode_remote_endpoint(st, &bet->st_endpoint);
 762                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_REMOTE_ENDPOINT);
 763                 break;
 764
 765             default:
 766                 zlog_debug("%s: unexpected subtlv type %d", __func__, st->type);
 767                 rc |= -1;
 768                 break;
 769         }
 770     }
 771     return rc;
 772 }
 773
 774 int
 775 tlv_to_bgp_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode(
 776     struct bgp_attr_encap_subtlv                                        *stlv,
 777     struct bgp_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode     *bet)
 778 {
 779     struct bgp_attr_encap_subtlv                *st;
 780     int                                         rc = 0;
 781
 782     for (st = stlv; st; st = st->next) {
 783         switch (st->type) {
 784             case BGP_ENCAP_SUBTLV_TYPE_IPSEC_TA:
 785                 rc |= subtlv_decode_ipsec_ta(st, &bet->st_ipsec_ta);
 786                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_IPSEC_TA);
 787                 break;
 788
 789             case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT:
 790                 rc |= subtlv_decode_remote_endpoint(st, &bet->st_endpoint);
 791                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_REMOTE_ENDPOINT);
 792                 break;
 793
 794             default:
 795                 zlog_debug("%s: unexpected subtlv type %d", __func__, st->type);
 796                 rc |= -1;
 797                 break;
 798         }
 799     }
 800     return rc;
 801 }
 802
 803 int
 804 tlv_to_bgp_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode(
 805     struct bgp_attr_encap_subtlv                                        *stlv,
 806     struct bgp_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode   *bet)
 807 {
 808     struct bgp_attr_encap_subtlv                *st;
 809     int                                         rc = 0;
 810
 811     for (st = stlv; st; st = st->next) {
 812         switch (st->type) {
 813             case BGP_ENCAP_SUBTLV_TYPE_IPSEC_TA:
 814                 rc |= subtlv_decode_ipsec_ta(st, &bet->st_ipsec_ta);
 815                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_IPSEC_TA);
 816                 break;
 817
 818             case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT:
 819                 rc |= subtlv_decode_remote_endpoint(st, &bet->st_endpoint);
 820                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_REMOTE_ENDPOINT);
 821                 break;
 822
 823             default:
 824                 zlog_debug("%s: unexpected subtlv type %d", __func__, st->type);
 825                 rc |= -1;
 826                 break;
 827         }
 828     }
 829     return rc;
 830 }
 831
 832 int
 833 tlv_to_bgp_encap_type_vxlan(
 834     struct bgp_attr_encap_subtlv        *stlv,
 835     struct bgp_encap_type_vxlan         *bet)
 836 {
 837     struct bgp_attr_encap_subtlv                *st;
 838     int                                         rc = 0;
 839
 840     for (st = stlv; st; st = st->next) {
 841         switch (st->type) {
 842
 843             case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT:
 844                 rc |= subtlv_decode_remote_endpoint(st, &bet->st_endpoint);
 845                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_REMOTE_ENDPOINT);
 846                 break;
 847
 848             default:
 849                 zlog_debug("%s: unexpected subtlv type %d", __func__, st->type);
 850                 rc |= -1;
 851                 break;
 852         }
 853     }
 854     return rc;
 855 }
 856
 857 int
 858 tlv_to_bgp_encap_type_nvgre(
 859     struct bgp_attr_encap_subtlv        *stlv,
 860     struct bgp_encap_type_nvgre         *bet)
 861 {
 862     struct bgp_attr_encap_subtlv                *st;
 863     int                                         rc = 0;
 864
 865     for (st = stlv; st; st = st->next) {
 866         switch (st->type) {
 867
 868             case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT:
 869                 rc |= subtlv_decode_remote_endpoint(st, &bet->st_endpoint);
 870                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_REMOTE_ENDPOINT);
 871                 break;
 872
 873             default:
 874                 zlog_debug("%s: unexpected subtlv type %d", __func__, st->type);
 875                 rc |= -1;
 876                 break;
 877         }
 878     }
 879     return rc;
 880 }
 881
 882 int
 883 tlv_to_bgp_encap_type_mpls(
 884     struct bgp_attr_encap_subtlv        *stlv,
 885     struct bgp_encap_type_mpls          *bet)
 886 {
 887     struct bgp_attr_encap_subtlv                *st;
 888     int                                         rc = 0;
 889
 890     for (st = stlv; st; st = st->next) {
 891         switch (st->type) {
 892
 893             case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT:
 894                 rc |= subtlv_decode_remote_endpoint(st, &bet->st_endpoint);
 895                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_REMOTE_ENDPOINT);
 896                 break;
 897
 898             default:
 899                 zlog_debug("%s: unexpected subtlv type %d", __func__, st->type);
 900                 rc |= -1;
 901                 break;
 902         }
 903     }
 904     return rc;
 905 }
 906
 907 int
 908 tlv_to_bgp_encap_type_mpls_in_gre(
 909     struct bgp_attr_encap_subtlv        *stlv,
 910     struct bgp_encap_type_mpls_in_gre   *bet)
 911 {
 912     struct bgp_attr_encap_subtlv                *st;
 913     int                                         rc = 0;
 914
 915     for (st = stlv; st; st = st->next) {
 916         switch (st->type) {
 917
 918             case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT:
 919                 rc |= subtlv_decode_remote_endpoint(st, &bet->st_endpoint);
 920                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_REMOTE_ENDPOINT);
 921                 break;
 922
 923             default:
 924                 zlog_debug("%s: unexpected subtlv type %d", __func__, st->type);
 925                 rc |= -1;
 926                 break;
 927         }
 928     }
 929     return rc;
 930 }
 931
 932 int
 933 tlv_to_bgp_encap_type_vxlan_gpe(
 934     struct bgp_attr_encap_subtlv        *stlv,
 935     struct bgp_encap_type_vxlan_gpe     *bet)
 936 {
 937     struct bgp_attr_encap_subtlv                *st;
 938     int                                         rc = 0;
 939
 940     for (st = stlv; st; st = st->next) {
 941         switch (st->type) {
 942
 943             case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT:
 944                 rc |= subtlv_decode_remote_endpoint(st, &bet->st_endpoint);
 945                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_REMOTE_ENDPOINT);
 946                 break;
 947
 948             default:
 949                 zlog_debug("%s: unexpected subtlv type %d", __func__, st->type);
 950                 rc |= -1;
 951                 break;
 952         }
 953     }
 954     return rc;
 955 }
 956
 957 int
 958 tlv_to_bgp_encap_type_mpls_in_udp(
 959     struct bgp_attr_encap_subtlv        *stlv,
 960     struct bgp_encap_type_mpls_in_udp   *bet)
 961 {
 962     struct bgp_attr_encap_subtlv                *st;
 963     int                                         rc = 0;
 964
 965     for (st = stlv; st; st = st->next) {
 966         switch (st->type) {
 967
 968             case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT:
 969                 rc |= subtlv_decode_remote_endpoint(st, &bet->st_endpoint);
 970                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_REMOTE_ENDPOINT);
 971                 break;
 972
 973             default:
 974                 zlog_debug("%s: unexpected subtlv type %d", __func__, st->type);
 975                 rc |= -1;
 976                 break;
 977         }
 978     }
 979     return rc;
 980 }
 981
 982 int
 983 tlv_to_bgp_encap_type_pbb(
 984     struct bgp_attr_encap_subtlv        *stlv,  /* subtlv chain */
 985     struct bgp_encap_type_pbb           *bet)   /* caller-allocated */
 986 {
 987     struct bgp_attr_encap_subtlv                *st;
 988     int                                         rc = 0;
 989
 990     for (st = stlv; st; st = st->next) {
 991         switch (st->type) {
 992             case BGP_ENCAP_SUBTLV_TYPE_ENCAPSULATION:
 993                 rc |= subtlv_decode_encap_pbb(st, &bet->st_encap);
 994                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_ENCAP);
 995                 break;
 996
 997             case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT:
 998                 rc |= subtlv_decode_remote_endpoint(st, &bet->st_endpoint);
 999                 SET_SUBTLV_FLAG(bet, BGP_TEA_SUBTLV_REMOTE_ENDPOINT);
1000                 break;
1001
1002             default:
1003                 zlog_debug("%s: unexpected subtlv type %d", __func__, st->type);
1004                 rc |= -1;
1005                 break;
1006         }
1007     }
1008     return rc;
1009 }
1010