Annotation of embedaddon/bird/proto/bgp/packets.c, revision 1.1
1.1 ! misho 1: /*
! 2: * BIRD -- BGP Packet Processing
! 3: *
! 4: * (c) 2000 Martin Mares <mj@ucw.cz>
! 5: *
! 6: * Can be freely distributed and used under the terms of the GNU GPL.
! 7: */
! 8:
! 9: #undef LOCAL_DEBUG
! 10:
! 11: #include "nest/bird.h"
! 12: #include "nest/iface.h"
! 13: #include "nest/protocol.h"
! 14: #include "nest/route.h"
! 15: #include "nest/attrs.h"
! 16: #include "nest/mrtdump.h"
! 17: #include "conf/conf.h"
! 18: #include "lib/unaligned.h"
! 19: #include "lib/socket.h"
! 20:
! 21: #include "nest/cli.h"
! 22:
! 23: #include "bgp.h"
! 24:
! 25:
! 26: #define BGP_RR_REQUEST 0
! 27: #define BGP_RR_BEGIN 1
! 28: #define BGP_RR_END 2
! 29:
! 30:
! 31: static struct tbf rl_rcv_update = TBF_DEFAULT_LOG_LIMITS;
! 32: static struct tbf rl_snd_update = TBF_DEFAULT_LOG_LIMITS;
! 33:
! 34: /* Table for state -> RFC 6608 FSM error subcodes */
! 35: static byte fsm_err_subcode[BS_MAX] = {
! 36: [BS_OPENSENT] = 1,
! 37: [BS_OPENCONFIRM] = 2,
! 38: [BS_ESTABLISHED] = 3
! 39: };
! 40:
! 41: /*
! 42: * MRT Dump format is not semantically specified.
! 43: * We will use these values in appropriate fields:
! 44: *
! 45: * Local AS, Remote AS - configured AS numbers for given BGP instance.
! 46: * Local IP, Remote IP - IP addresses of the TCP connection (0 if no connection)
! 47: *
! 48: * We dump two kinds of MRT messages: STATE_CHANGE (for BGP state
! 49: * changes) and MESSAGE (for received BGP messages).
! 50: *
! 51: * STATE_CHANGE uses always AS4 variant, but MESSAGE uses AS4 variant
! 52: * only when AS4 session is established and even in that case MESSAGE
! 53: * does not use AS4 variant for initial OPEN message. This strange
! 54: * behavior is here for compatibility with Quagga and Bgpdump,
! 55: */
! 56:
! 57: static byte *
! 58: mrt_put_bgp4_hdr(byte *buf, struct bgp_conn *conn, int as4)
! 59: {
! 60: struct bgp_proto *p = conn->bgp;
! 61:
! 62: if (as4)
! 63: {
! 64: put_u32(buf+0, p->remote_as);
! 65: put_u32(buf+4, p->local_as);
! 66: buf+=8;
! 67: }
! 68: else
! 69: {
! 70: put_u16(buf+0, (p->remote_as <= 0xFFFF) ? p->remote_as : AS_TRANS);
! 71: put_u16(buf+2, (p->local_as <= 0xFFFF) ? p->local_as : AS_TRANS);
! 72: buf+=4;
! 73: }
! 74:
! 75: put_u16(buf+0, (p->neigh && p->neigh->iface) ? p->neigh->iface->index : 0);
! 76: put_u16(buf+2, BGP_AF);
! 77: buf+=4;
! 78: buf = put_ipa(buf, conn->sk ? conn->sk->daddr : IPA_NONE);
! 79: buf = put_ipa(buf, conn->sk ? conn->sk->saddr : IPA_NONE);
! 80:
! 81: return buf;
! 82: }
! 83:
! 84: static void
! 85: mrt_dump_bgp_packet(struct bgp_conn *conn, byte *pkt, unsigned len)
! 86: {
! 87: byte *buf = alloca(128+len); /* 128 is enough for MRT headers */
! 88: byte *bp = buf + MRTDUMP_HDR_LENGTH;
! 89: int as4 = conn->bgp->as4_session;
! 90:
! 91: bp = mrt_put_bgp4_hdr(bp, conn, as4);
! 92: memcpy(bp, pkt, len);
! 93: bp += len;
! 94: mrt_dump_message(&conn->bgp->p, BGP4MP, as4 ? BGP4MP_MESSAGE_AS4 : BGP4MP_MESSAGE,
! 95: buf, bp-buf);
! 96: }
! 97:
! 98: static inline u16
! 99: convert_state(unsigned state)
! 100: {
! 101: /* Convert state from our BS_* values to values used in MRTDump */
! 102: return (state == BS_CLOSE) ? 1 : state + 1;
! 103: }
! 104:
! 105: void
! 106: mrt_dump_bgp_state_change(struct bgp_conn *conn, unsigned old, unsigned new)
! 107: {
! 108: byte buf[128];
! 109: byte *bp = buf + MRTDUMP_HDR_LENGTH;
! 110:
! 111: bp = mrt_put_bgp4_hdr(bp, conn, 1);
! 112: put_u16(bp+0, convert_state(old));
! 113: put_u16(bp+2, convert_state(new));
! 114: bp += 4;
! 115: mrt_dump_message(&conn->bgp->p, BGP4MP, BGP4MP_STATE_CHANGE_AS4, buf, bp-buf);
! 116: }
! 117:
! 118: static byte *
! 119: bgp_create_notification(struct bgp_conn *conn, byte *buf)
! 120: {
! 121: struct bgp_proto *p = conn->bgp;
! 122:
! 123: BGP_TRACE(D_PACKETS, "Sending NOTIFICATION(code=%d.%d)", conn->notify_code, conn->notify_subcode);
! 124: buf[0] = conn->notify_code;
! 125: buf[1] = conn->notify_subcode;
! 126: memcpy(buf+2, conn->notify_data, conn->notify_size);
! 127: return buf + 2 + conn->notify_size;
! 128: }
! 129:
! 130: #ifdef IPV6
! 131: static byte *
! 132: bgp_put_cap_ipv6(struct bgp_proto *p UNUSED, byte *buf)
! 133: {
! 134: *buf++ = 1; /* Capability 1: Multiprotocol extensions */
! 135: *buf++ = 4; /* Capability data length */
! 136: *buf++ = 0; /* We support AF IPv6 */
! 137: *buf++ = BGP_AF_IPV6;
! 138: *buf++ = 0; /* RFU */
! 139: *buf++ = 1; /* and SAFI 1 */
! 140: return buf;
! 141: }
! 142:
! 143: #else
! 144:
! 145: static byte *
! 146: bgp_put_cap_ipv4(struct bgp_proto *p UNUSED, byte *buf)
! 147: {
! 148: *buf++ = 1; /* Capability 1: Multiprotocol extensions */
! 149: *buf++ = 4; /* Capability data length */
! 150: *buf++ = 0; /* We support AF IPv4 */
! 151: *buf++ = BGP_AF_IPV4;
! 152: *buf++ = 0; /* RFU */
! 153: *buf++ = 1; /* and SAFI 1 */
! 154: return buf;
! 155: }
! 156: #endif
! 157:
! 158: static byte *
! 159: bgp_put_cap_rr(struct bgp_proto *p UNUSED, byte *buf)
! 160: {
! 161: *buf++ = 2; /* Capability 2: Support for route refresh */
! 162: *buf++ = 0; /* Capability data length */
! 163: return buf;
! 164: }
! 165:
! 166: static byte *
! 167: bgp_put_cap_ext_msg(struct bgp_proto *p UNUSED, byte *buf)
! 168: {
! 169: *buf++ = 6; /* Capability 6: Support for extended messages */
! 170: *buf++ = 0; /* Capability data length */
! 171: return buf;
! 172: }
! 173:
! 174: static byte *
! 175: bgp_put_cap_gr1(struct bgp_proto *p, byte *buf)
! 176: {
! 177: *buf++ = 64; /* Capability 64: Support for graceful restart */
! 178: *buf++ = 6; /* Capability data length */
! 179:
! 180: put_u16(buf, p->cf->gr_time);
! 181: if (p->p.gr_recovery)
! 182: buf[0] |= BGP_GRF_RESTART;
! 183: buf += 2;
! 184:
! 185: *buf++ = 0; /* Appropriate AF */
! 186: *buf++ = BGP_AF;
! 187: *buf++ = 1; /* and SAFI 1 */
! 188: *buf++ = p->p.gr_recovery ? BGP_GRF_FORWARDING : 0;
! 189:
! 190: return buf;
! 191: }
! 192:
! 193: static byte *
! 194: bgp_put_cap_gr2(struct bgp_proto *p UNUSED, byte *buf)
! 195: {
! 196: *buf++ = 64; /* Capability 64: Support for graceful restart */
! 197: *buf++ = 2; /* Capability data length */
! 198: put_u16(buf, 0);
! 199: return buf + 2;
! 200: }
! 201:
! 202: static byte *
! 203: bgp_put_cap_as4(struct bgp_proto *p, byte *buf)
! 204: {
! 205: *buf++ = 65; /* Capability 65: Support for 4-octet AS number */
! 206: *buf++ = 4; /* Capability data length */
! 207: put_u32(buf, p->local_as);
! 208: return buf + 4;
! 209: }
! 210:
! 211: static byte *
! 212: bgp_put_cap_add_path(struct bgp_proto *p, byte *buf)
! 213: {
! 214: *buf++ = 69; /* Capability 69: Support for ADD-PATH */
! 215: *buf++ = 4; /* Capability data length */
! 216:
! 217: *buf++ = 0; /* Appropriate AF */
! 218: *buf++ = BGP_AF;
! 219: *buf++ = 1; /* SAFI 1 */
! 220:
! 221: *buf++ = p->cf->add_path;
! 222:
! 223: return buf;
! 224: }
! 225:
! 226: static byte *
! 227: bgp_put_cap_err(struct bgp_proto *p UNUSED, byte *buf)
! 228: {
! 229: *buf++ = 70; /* Capability 70: Support for enhanced route refresh */
! 230: *buf++ = 0; /* Capability data length */
! 231: return buf;
! 232: }
! 233:
! 234:
! 235: static byte *
! 236: bgp_create_open(struct bgp_conn *conn, byte *buf)
! 237: {
! 238: struct bgp_proto *p = conn->bgp;
! 239: byte *cap;
! 240: int cap_len;
! 241:
! 242: BGP_TRACE(D_PACKETS, "Sending OPEN(ver=%d,as=%d,hold=%d,id=%08x)",
! 243: BGP_VERSION, p->local_as, p->cf->hold_time, p->local_id);
! 244: buf[0] = BGP_VERSION;
! 245: put_u16(buf+1, (p->local_as < 0xFFFF) ? p->local_as : AS_TRANS);
! 246: put_u16(buf+3, p->cf->hold_time);
! 247: put_u32(buf+5, p->local_id);
! 248:
! 249: if (conn->start_state == BSS_CONNECT_NOCAP)
! 250: {
! 251: BGP_TRACE(D_PACKETS, "Skipping capabilities");
! 252: buf[9] = 0;
! 253: return buf + 10;
! 254: }
! 255:
! 256: /* Skipped 3 B for length field and Capabilities parameter header */
! 257: cap = buf + 12;
! 258:
! 259: #ifndef IPV6
! 260: if (p->cf->advertise_ipv4)
! 261: cap = bgp_put_cap_ipv4(p, cap);
! 262: #endif
! 263:
! 264: #ifdef IPV6
! 265: cap = bgp_put_cap_ipv6(p, cap);
! 266: #endif
! 267:
! 268: if (p->cf->enable_refresh)
! 269: cap = bgp_put_cap_rr(p, cap);
! 270:
! 271: if (p->cf->gr_mode == BGP_GR_ABLE)
! 272: cap = bgp_put_cap_gr1(p, cap);
! 273: else if (p->cf->gr_mode == BGP_GR_AWARE)
! 274: cap = bgp_put_cap_gr2(p, cap);
! 275:
! 276: if (p->cf->enable_as4)
! 277: cap = bgp_put_cap_as4(p, cap);
! 278:
! 279: if (p->cf->add_path)
! 280: cap = bgp_put_cap_add_path(p, cap);
! 281:
! 282: if (p->cf->enable_refresh)
! 283: cap = bgp_put_cap_err(p, cap);
! 284:
! 285: if (p->cf->enable_extended_messages)
! 286: cap = bgp_put_cap_ext_msg(p, cap);
! 287:
! 288: cap_len = cap - buf - 12;
! 289: if (cap_len > 0)
! 290: {
! 291: buf[9] = cap_len + 2; /* Optional params len */
! 292: buf[10] = 2; /* Option: Capability list */
! 293: buf[11] = cap_len; /* Option length */
! 294: return cap;
! 295: }
! 296: else
! 297: {
! 298: buf[9] = 0; /* No optional parameters */
! 299: return buf + 10;
! 300: }
! 301: }
! 302:
! 303: static uint
! 304: bgp_encode_prefixes(struct bgp_proto *p, byte *w, struct bgp_bucket *buck, uint remains)
! 305: {
! 306: byte *start = w;
! 307: ip_addr a;
! 308: int bytes;
! 309:
! 310: while (!EMPTY_LIST(buck->prefixes) && (remains >= (5+sizeof(ip_addr))))
! 311: {
! 312: struct bgp_prefix *px = SKIP_BACK(struct bgp_prefix, bucket_node, HEAD(buck->prefixes));
! 313: DBG("\tDequeued route %I/%d\n", px->n.prefix, px->n.pxlen);
! 314:
! 315: if (p->add_path_tx)
! 316: {
! 317: put_u32(w, px->path_id);
! 318: w += 4;
! 319: remains -= 4;
! 320: }
! 321:
! 322: *w++ = px->n.pxlen;
! 323: bytes = (px->n.pxlen + 7) / 8;
! 324: a = px->n.prefix;
! 325: ipa_hton(a);
! 326: memcpy(w, &a, bytes);
! 327: w += bytes;
! 328: remains -= bytes + 1;
! 329: rem_node(&px->bucket_node);
! 330: bgp_free_prefix(p, px);
! 331: // fib_delete(&p->prefix_fib, px);
! 332: }
! 333: return w - start;
! 334: }
! 335:
! 336: static void
! 337: bgp_flush_prefixes(struct bgp_proto *p, struct bgp_bucket *buck)
! 338: {
! 339: while (!EMPTY_LIST(buck->prefixes))
! 340: {
! 341: struct bgp_prefix *px = SKIP_BACK(struct bgp_prefix, bucket_node, HEAD(buck->prefixes));
! 342: log(L_ERR "%s: - route %I/%d skipped", p->p.name, px->n.prefix, px->n.pxlen);
! 343: rem_node(&px->bucket_node);
! 344: bgp_free_prefix(p, px);
! 345: // fib_delete(&p->prefix_fib, px);
! 346: }
! 347: }
! 348:
! 349: #ifndef IPV6 /* IPv4 version */
! 350:
! 351: static byte *
! 352: bgp_create_update(struct bgp_conn *conn, byte *buf)
! 353: {
! 354: struct bgp_proto *p = conn->bgp;
! 355: struct bgp_bucket *buck;
! 356: int remains = bgp_max_packet_length(p) - BGP_HEADER_LENGTH - 4;
! 357: byte *w;
! 358: int wd_size = 0;
! 359: int r_size = 0;
! 360: int a_size = 0;
! 361:
! 362: w = buf+2;
! 363: if ((buck = p->withdraw_bucket) && !EMPTY_LIST(buck->prefixes))
! 364: {
! 365: DBG("Withdrawn routes:\n");
! 366: wd_size = bgp_encode_prefixes(p, w, buck, remains);
! 367: w += wd_size;
! 368: remains -= wd_size;
! 369: }
! 370: put_u16(buf, wd_size);
! 371:
! 372: if (!wd_size)
! 373: {
! 374: while ((buck = (struct bgp_bucket *) HEAD(p->bucket_queue))->send_node.next)
! 375: {
! 376: if (EMPTY_LIST(buck->prefixes))
! 377: {
! 378: DBG("Deleting empty bucket %p\n", buck);
! 379: rem_node(&buck->send_node);
! 380: bgp_free_bucket(p, buck);
! 381: continue;
! 382: }
! 383:
! 384: DBG("Processing bucket %p\n", buck);
! 385: a_size = bgp_encode_attrs(p, w+2, buck->eattrs, remains - 1024);
! 386:
! 387: if (a_size < 0)
! 388: {
! 389: log(L_ERR "%s: Attribute list too long, skipping corresponding routes", p->p.name);
! 390: bgp_flush_prefixes(p, buck);
! 391: rem_node(&buck->send_node);
! 392: bgp_free_bucket(p, buck);
! 393: continue;
! 394: }
! 395:
! 396: put_u16(w, a_size);
! 397: w += a_size + 2;
! 398: r_size = bgp_encode_prefixes(p, w, buck, remains - a_size);
! 399: w += r_size;
! 400: break;
! 401: }
! 402: }
! 403: if (!a_size) /* Attributes not already encoded */
! 404: {
! 405: put_u16(w, 0);
! 406: w += 2;
! 407: }
! 408: if (wd_size || r_size)
! 409: {
! 410: BGP_TRACE_RL(&rl_snd_update, D_PACKETS, "Sending UPDATE");
! 411: return w;
! 412: }
! 413: else
! 414: return NULL;
! 415: }
! 416:
! 417: static byte *
! 418: bgp_create_end_mark(struct bgp_conn *conn, byte *buf)
! 419: {
! 420: struct bgp_proto *p = conn->bgp;
! 421: BGP_TRACE(D_PACKETS, "Sending END-OF-RIB");
! 422:
! 423: put_u32(buf, 0);
! 424: return buf+4;
! 425: }
! 426:
! 427: #else /* IPv6 version */
! 428:
! 429: static inline int
! 430: same_iface(struct bgp_proto *p, ip_addr *ip)
! 431: {
! 432: neighbor *n = neigh_find(&p->p, ip, 0);
! 433: return n && p->neigh && n->iface == p->neigh->iface;
! 434: }
! 435:
! 436: static byte *
! 437: bgp_create_update(struct bgp_conn *conn, byte *buf)
! 438: {
! 439: struct bgp_proto *p = conn->bgp;
! 440: struct bgp_bucket *buck;
! 441: int size, second, rem_stored;
! 442: int remains = bgp_max_packet_length(p) - BGP_HEADER_LENGTH - 4;
! 443: byte *w, *w_stored, *tmp, *tstart;
! 444: ip_addr *ipp, ip, ip_ll;
! 445: ea_list *ea;
! 446: eattr *nh;
! 447:
! 448: put_u16(buf, 0);
! 449: w = buf+4;
! 450:
! 451: if ((buck = p->withdraw_bucket) && !EMPTY_LIST(buck->prefixes))
! 452: {
! 453: DBG("Withdrawn routes:\n");
! 454: tmp = bgp_attach_attr_wa(&ea, bgp_linpool, BA_MP_UNREACH_NLRI, remains-8);
! 455: *tmp++ = 0;
! 456: *tmp++ = BGP_AF_IPV6;
! 457: *tmp++ = 1;
! 458: ea->attrs[0].u.ptr->length = 3 + bgp_encode_prefixes(p, tmp, buck, remains-11);
! 459: size = bgp_encode_attrs(p, w, ea, remains);
! 460: ASSERT(size >= 0);
! 461: w += size;
! 462: remains -= size;
! 463: }
! 464: else
! 465: {
! 466: while ((buck = (struct bgp_bucket *) HEAD(p->bucket_queue))->send_node.next)
! 467: {
! 468: if (EMPTY_LIST(buck->prefixes))
! 469: {
! 470: DBG("Deleting empty bucket %p\n", buck);
! 471: rem_node(&buck->send_node);
! 472: bgp_free_bucket(p, buck);
! 473: continue;
! 474: }
! 475:
! 476: DBG("Processing bucket %p\n", buck);
! 477: rem_stored = remains;
! 478: w_stored = w;
! 479:
! 480: size = bgp_encode_attrs(p, w, buck->eattrs, remains - 1024);
! 481: if (size < 0)
! 482: {
! 483: log(L_ERR "%s: Attribute list too long, skipping corresponding routes", p->p.name);
! 484: bgp_flush_prefixes(p, buck);
! 485: rem_node(&buck->send_node);
! 486: bgp_free_bucket(p, buck);
! 487: continue;
! 488: }
! 489: w += size;
! 490: remains -= size;
! 491:
! 492: /* We have two addresses here in NEXT_HOP eattr. Really.
! 493: Unless NEXT_HOP was modified by filter */
! 494: nh = ea_find(buck->eattrs, EA_CODE(EAP_BGP, BA_NEXT_HOP));
! 495: ASSERT(nh);
! 496: second = (nh->u.ptr->length == NEXT_HOP_LENGTH);
! 497: ipp = (ip_addr *) nh->u.ptr->data;
! 498: ip = ipp[0];
! 499: ip_ll = IPA_NONE;
! 500:
! 501: if (ipa_equal(ip, p->source_addr))
! 502: ip_ll = p->local_link;
! 503: else
! 504: {
! 505: /* If we send a route with 'third party' next hop destinated
! 506: * in the same interface, we should also send a link local
! 507: * next hop address. We use the received one (stored in the
! 508: * other part of BA_NEXT_HOP eattr). If we didn't received
! 509: * it (for example it is a static route), we can't use
! 510: * 'third party' next hop and we have to use local IP address
! 511: * as next hop. Sending original next hop address without
! 512: * link local address seems to be a natural way to solve that
! 513: * problem, but it is contrary to RFC 2545 and Quagga does not
! 514: * accept such routes.
! 515: *
! 516: * There are two cases, either we have global IP, or
! 517: * IPA_NONE if the neighbor is link-local. For IPA_NONE,
! 518: * we suppose it is on the same iface, see bgp_update_attrs().
! 519: */
! 520:
! 521: if (ipa_zero(ip) || same_iface(p, &ip))
! 522: {
! 523: if (second && ipa_nonzero(ipp[1]))
! 524: ip_ll = ipp[1];
! 525: else
! 526: {
! 527: switch (p->cf->missing_lladdr)
! 528: {
! 529: case MLL_SELF:
! 530: ip = p->source_addr;
! 531: ip_ll = p->local_link;
! 532: break;
! 533: case MLL_DROP:
! 534: log(L_ERR "%s: Missing link-local next hop address, skipping corresponding routes", p->p.name);
! 535: w = w_stored;
! 536: remains = rem_stored;
! 537: bgp_flush_prefixes(p, buck);
! 538: rem_node(&buck->send_node);
! 539: bgp_free_bucket(p, buck);
! 540: continue;
! 541: case MLL_IGNORE:
! 542: break;
! 543: }
! 544: }
! 545: }
! 546: }
! 547:
! 548: tstart = tmp = bgp_attach_attr_wa(&ea, bgp_linpool, BA_MP_REACH_NLRI, remains-8);
! 549: *tmp++ = 0;
! 550: *tmp++ = BGP_AF_IPV6;
! 551: *tmp++ = 1;
! 552:
! 553: if (ipa_is_link_local(ip))
! 554: ip = IPA_NONE;
! 555:
! 556: if (ipa_nonzero(ip_ll))
! 557: {
! 558: *tmp++ = 32;
! 559: ipa_hton(ip);
! 560: memcpy(tmp, &ip, 16);
! 561: ipa_hton(ip_ll);
! 562: memcpy(tmp+16, &ip_ll, 16);
! 563: tmp += 32;
! 564: }
! 565: else
! 566: {
! 567: *tmp++ = 16;
! 568: ipa_hton(ip);
! 569: memcpy(tmp, &ip, 16);
! 570: tmp += 16;
! 571: }
! 572:
! 573: *tmp++ = 0; /* No SNPA information */
! 574: tmp += bgp_encode_prefixes(p, tmp, buck, remains - (8+3+32+1));
! 575: ea->attrs[0].u.ptr->length = tmp - tstart;
! 576: size = bgp_encode_attrs(p, w, ea, remains);
! 577: ASSERT(size >= 0);
! 578: w += size;
! 579: break;
! 580: }
! 581: }
! 582:
! 583: size = w - (buf+4);
! 584: put_u16(buf+2, size);
! 585: lp_flush(bgp_linpool);
! 586: if (size)
! 587: {
! 588: BGP_TRACE_RL(&rl_snd_update, D_PACKETS, "Sending UPDATE");
! 589: return w;
! 590: }
! 591: else
! 592: return NULL;
! 593: }
! 594:
! 595: static byte *
! 596: bgp_create_end_mark(struct bgp_conn *conn, byte *buf)
! 597: {
! 598: struct bgp_proto *p = conn->bgp;
! 599: BGP_TRACE(D_PACKETS, "Sending END-OF-RIB");
! 600:
! 601: put_u16(buf+0, 0);
! 602: put_u16(buf+2, 6); /* length 4-9 */
! 603: buf += 4;
! 604:
! 605: /* Empty MP_UNREACH_NLRI atribute */
! 606: *buf++ = BAF_OPTIONAL;
! 607: *buf++ = BA_MP_UNREACH_NLRI;
! 608: *buf++ = 3; /* Length 7-9 */
! 609: *buf++ = 0; /* AFI */
! 610: *buf++ = BGP_AF_IPV6;
! 611: *buf++ = 1; /* SAFI */
! 612: return buf;
! 613: }
! 614:
! 615: #endif
! 616:
! 617: static inline byte *
! 618: bgp_create_route_refresh(struct bgp_conn *conn, byte *buf)
! 619: {
! 620: struct bgp_proto *p = conn->bgp;
! 621: BGP_TRACE(D_PACKETS, "Sending ROUTE-REFRESH");
! 622:
! 623: /* Original original route refresh request, RFC 2918 */
! 624: *buf++ = 0;
! 625: *buf++ = BGP_AF;
! 626: *buf++ = BGP_RR_REQUEST;
! 627: *buf++ = 1; /* SAFI */
! 628: return buf;
! 629: }
! 630:
! 631: static inline byte *
! 632: bgp_create_begin_refresh(struct bgp_conn *conn, byte *buf)
! 633: {
! 634: struct bgp_proto *p = conn->bgp;
! 635: BGP_TRACE(D_PACKETS, "Sending BEGIN-OF-RR");
! 636:
! 637: /* Demarcation of beginning of route refresh (BoRR), RFC 7313 */
! 638: *buf++ = 0;
! 639: *buf++ = BGP_AF;
! 640: *buf++ = BGP_RR_BEGIN;
! 641: *buf++ = 1; /* SAFI */
! 642: return buf;
! 643: }
! 644:
! 645: static inline byte *
! 646: bgp_create_end_refresh(struct bgp_conn *conn, byte *buf)
! 647: {
! 648: struct bgp_proto *p = conn->bgp;
! 649: BGP_TRACE(D_PACKETS, "Sending END-OF-RR");
! 650:
! 651: /* Demarcation of ending of route refresh (EoRR), RFC 7313 */
! 652: *buf++ = 0;
! 653: *buf++ = BGP_AF;
! 654: *buf++ = BGP_RR_END;
! 655: *buf++ = 1; /* SAFI */
! 656: return buf;
! 657: }
! 658:
! 659:
! 660: static void
! 661: bgp_create_header(byte *buf, uint len, uint type)
! 662: {
! 663: memset(buf, 0xff, 16); /* Marker */
! 664: put_u16(buf+16, len);
! 665: buf[18] = type;
! 666: }
! 667:
! 668: /**
! 669: * bgp_fire_tx - transmit packets
! 670: * @conn: connection
! 671: *
! 672: * Whenever the transmit buffers of the underlying TCP connection
! 673: * are free and we have any packets queued for sending, the socket functions
! 674: * call bgp_fire_tx() which takes care of selecting the highest priority packet
! 675: * queued (Notification > Keepalive > Open > Update), assembling its header
! 676: * and body and sending it to the connection.
! 677: */
! 678: static int
! 679: bgp_fire_tx(struct bgp_conn *conn)
! 680: {
! 681: struct bgp_proto *p = conn->bgp;
! 682: uint s = conn->packets_to_send;
! 683: sock *sk = conn->sk;
! 684: byte *buf, *pkt, *end;
! 685: int type;
! 686:
! 687: if (!sk)
! 688: {
! 689: conn->packets_to_send = 0;
! 690: return 0;
! 691: }
! 692: buf = sk->tbuf;
! 693: pkt = buf + BGP_HEADER_LENGTH;
! 694:
! 695: if (s & (1 << PKT_SCHEDULE_CLOSE))
! 696: {
! 697: /* We can finally close connection and enter idle state */
! 698: bgp_conn_enter_idle_state(conn);
! 699: return 0;
! 700: }
! 701: if (s & (1 << PKT_NOTIFICATION))
! 702: {
! 703: s = 1 << PKT_SCHEDULE_CLOSE;
! 704: type = PKT_NOTIFICATION;
! 705: end = bgp_create_notification(conn, pkt);
! 706: }
! 707: else if (s & (1 << PKT_KEEPALIVE))
! 708: {
! 709: s &= ~(1 << PKT_KEEPALIVE);
! 710: type = PKT_KEEPALIVE;
! 711: end = pkt; /* Keepalives carry no data */
! 712: BGP_TRACE(D_PACKETS, "Sending KEEPALIVE");
! 713: bgp_start_timer(conn->keepalive_timer, conn->keepalive_time);
! 714: }
! 715: else if (s & (1 << PKT_OPEN))
! 716: {
! 717: s &= ~(1 << PKT_OPEN);
! 718: type = PKT_OPEN;
! 719: end = bgp_create_open(conn, pkt);
! 720: }
! 721: else if (s & (1 << PKT_ROUTE_REFRESH))
! 722: {
! 723: s &= ~(1 << PKT_ROUTE_REFRESH);
! 724: type = PKT_ROUTE_REFRESH;
! 725: end = bgp_create_route_refresh(conn, pkt);
! 726: }
! 727: else if (s & (1 << PKT_BEGIN_REFRESH))
! 728: {
! 729: s &= ~(1 << PKT_BEGIN_REFRESH);
! 730: type = PKT_ROUTE_REFRESH; /* BoRR is a subtype of RR */
! 731: end = bgp_create_begin_refresh(conn, pkt);
! 732: }
! 733: else if (s & (1 << PKT_UPDATE))
! 734: {
! 735: type = PKT_UPDATE;
! 736: end = bgp_create_update(conn, pkt);
! 737:
! 738: if (!end)
! 739: {
! 740: /* No update to send, perhaps we need to send End-of-RIB or EoRR */
! 741:
! 742: conn->packets_to_send = 0;
! 743:
! 744: if (p->feed_state == BFS_LOADED)
! 745: {
! 746: type = PKT_UPDATE;
! 747: end = bgp_create_end_mark(conn, pkt);
! 748: }
! 749:
! 750: else if (p->feed_state == BFS_REFRESHED)
! 751: {
! 752: type = PKT_ROUTE_REFRESH;
! 753: end = bgp_create_end_refresh(conn, pkt);
! 754: }
! 755:
! 756: else /* Really nothing to send */
! 757: return 0;
! 758:
! 759: p->feed_state = BFS_NONE;
! 760: }
! 761: }
! 762: else
! 763: return 0;
! 764:
! 765: conn->packets_to_send = s;
! 766: bgp_create_header(buf, end - buf, type);
! 767: return sk_send(sk, end - buf);
! 768: }
! 769:
! 770: /**
! 771: * bgp_schedule_packet - schedule a packet for transmission
! 772: * @conn: connection
! 773: * @type: packet type
! 774: *
! 775: * Schedule a packet of type @type to be sent as soon as possible.
! 776: */
! 777: void
! 778: bgp_schedule_packet(struct bgp_conn *conn, int type)
! 779: {
! 780: DBG("BGP: Scheduling packet type %d\n", type);
! 781: conn->packets_to_send |= 1 << type;
! 782: if (conn->sk && conn->sk->tpos == conn->sk->tbuf && !ev_active(conn->tx_ev))
! 783: ev_schedule(conn->tx_ev);
! 784: }
! 785:
! 786: void
! 787: bgp_kick_tx(void *vconn)
! 788: {
! 789: struct bgp_conn *conn = vconn;
! 790:
! 791: DBG("BGP: kicking TX\n");
! 792: while (bgp_fire_tx(conn) > 0)
! 793: ;
! 794: }
! 795:
! 796: void
! 797: bgp_tx(sock *sk)
! 798: {
! 799: struct bgp_conn *conn = sk->data;
! 800:
! 801: DBG("BGP: TX hook\n");
! 802: while (bgp_fire_tx(conn) > 0)
! 803: ;
! 804: }
! 805:
! 806: /* Capatibility negotiation as per RFC 2842 */
! 807:
! 808: void
! 809: bgp_parse_capabilities(struct bgp_conn *conn, byte *opt, int len)
! 810: {
! 811: // struct bgp_proto *p = conn->bgp;
! 812: int i, cl;
! 813:
! 814: while (len > 0)
! 815: {
! 816: if (len < 2 || len < 2 + opt[1])
! 817: goto err;
! 818:
! 819: cl = opt[1];
! 820:
! 821: switch (opt[0])
! 822: {
! 823: case 2: /* Route refresh capability, RFC 2918 */
! 824: if (cl != 0)
! 825: goto err;
! 826: conn->peer_refresh_support = 1;
! 827: break;
! 828:
! 829: case 6: /* Extended message length capability, draft */
! 830: if (cl != 0)
! 831: goto err;
! 832: conn->peer_ext_messages_support = 1;
! 833: break;
! 834:
! 835: case 64: /* Graceful restart capability, RFC 4724 */
! 836: if (cl % 4 != 2)
! 837: goto err;
! 838: conn->peer_gr_aware = 1;
! 839: conn->peer_gr_able = 0;
! 840: conn->peer_gr_time = get_u16(opt + 2) & 0x0fff;
! 841: conn->peer_gr_flags = opt[2] & 0xf0;
! 842: conn->peer_gr_aflags = 0;
! 843: for (i = 2; i < cl; i += 4)
! 844: if (opt[2+i+0] == 0 && opt[2+i+1] == BGP_AF && opt[2+i+2] == 1) /* Match AFI/SAFI */
! 845: {
! 846: conn->peer_gr_able = 1;
! 847: conn->peer_gr_aflags = opt[2+i+3];
! 848: }
! 849: break;
! 850:
! 851: case 65: /* AS4 capability, RFC 4893 */
! 852: if (cl != 4)
! 853: goto err;
! 854: conn->peer_as4_support = 1;
! 855: if (conn->bgp->cf->enable_as4)
! 856: conn->advertised_as = get_u32(opt + 2);
! 857: break;
! 858:
! 859: case 69: /* ADD-PATH capability, draft */
! 860: if (cl % 4)
! 861: goto err;
! 862: for (i = 0; i < cl; i += 4)
! 863: if (opt[2+i+0] == 0 && opt[2+i+1] == BGP_AF && opt[2+i+2] == 1) /* Match AFI/SAFI */
! 864: conn->peer_add_path = opt[2+i+3];
! 865: if (conn->peer_add_path > ADD_PATH_FULL)
! 866: goto err;
! 867: break;
! 868:
! 869: case 70: /* Enhanced route refresh capability, RFC 7313 */
! 870: if (cl != 0)
! 871: goto err;
! 872: conn->peer_enhanced_refresh_support = 1;
! 873: break;
! 874:
! 875: /* We can safely ignore all other capabilities */
! 876: }
! 877: len -= 2 + cl;
! 878: opt += 2 + cl;
! 879: }
! 880: return;
! 881:
! 882: err:
! 883: bgp_error(conn, 2, 0, NULL, 0);
! 884: return;
! 885: }
! 886:
! 887: static int
! 888: bgp_parse_options(struct bgp_conn *conn, byte *opt, int len)
! 889: {
! 890: struct bgp_proto *p = conn->bgp;
! 891: int ol;
! 892:
! 893: while (len > 0)
! 894: {
! 895: if (len < 2 || len < 2 + opt[1])
! 896: { bgp_error(conn, 2, 0, NULL, 0); return 0; }
! 897: #ifdef LOCAL_DEBUG
! 898: {
! 899: int i;
! 900: DBG("\tOption %02x:", opt[0]);
! 901: for(i=0; i<opt[1]; i++)
! 902: DBG(" %02x", opt[2+i]);
! 903: DBG("\n");
! 904: }
! 905: #endif
! 906:
! 907: ol = opt[1];
! 908: switch (opt[0])
! 909: {
! 910: case 2:
! 911: if (conn->start_state == BSS_CONNECT_NOCAP)
! 912: BGP_TRACE(D_PACKETS, "Ignoring received capabilities");
! 913: else
! 914: bgp_parse_capabilities(conn, opt + 2, ol);
! 915: break;
! 916:
! 917: default:
! 918: /*
! 919: * BGP specs don't tell us to send which option
! 920: * we didn't recognize, but it's common practice
! 921: * to do so. Also, capability negotiation with
! 922: * Cisco routers doesn't work without that.
! 923: */
! 924: bgp_error(conn, 2, 4, opt, ol);
! 925: return 0;
! 926: }
! 927: len -= 2 + ol;
! 928: opt += 2 + ol;
! 929: }
! 930: return 0;
! 931: }
! 932:
! 933: static void
! 934: bgp_rx_open(struct bgp_conn *conn, byte *pkt, uint len)
! 935: {
! 936: struct bgp_conn *other;
! 937: struct bgp_proto *p = conn->bgp;
! 938: unsigned hold;
! 939: u16 base_as;
! 940: u32 id;
! 941:
! 942: /* Check state */
! 943: if (conn->state != BS_OPENSENT)
! 944: { bgp_error(conn, 5, fsm_err_subcode[conn->state], NULL, 0); return; }
! 945:
! 946: /* Check message contents */
! 947: if (len < 29 || len != 29U + pkt[28])
! 948: { bgp_error(conn, 1, 2, pkt+16, 2); return; }
! 949: if (pkt[19] != BGP_VERSION)
! 950: { bgp_error(conn, 2, 1, pkt+19, 1); return; } /* RFC 1771 says 16 bits, draft-09 tells to use 8 */
! 951: conn->advertised_as = base_as = get_u16(pkt+20);
! 952: hold = get_u16(pkt+22);
! 953: id = get_u32(pkt+24);
! 954: BGP_TRACE(D_PACKETS, "Got OPEN(as=%d,hold=%d,id=%08x)", conn->advertised_as, hold, id);
! 955:
! 956: if (bgp_parse_options(conn, pkt+29, pkt[28]))
! 957: return;
! 958:
! 959: if (hold > 0 && hold < 3)
! 960: { bgp_error(conn, 2, 6, pkt+22, 2); return; }
! 961:
! 962: /* RFC 6286 2.2 - router ID is nonzero and AS-wide unique */
! 963: if (!id || (p->is_internal && id == p->local_id))
! 964: { bgp_error(conn, 2, 3, pkt+24, -4); return; }
! 965:
! 966: if ((conn->advertised_as != base_as) && (base_as != AS_TRANS))
! 967: log(L_WARN "%s: Peer advertised inconsistent AS numbers", p->p.name);
! 968:
! 969: if (conn->advertised_as != p->remote_as)
! 970: {
! 971: if (conn->peer_as4_support)
! 972: {
! 973: u32 val = htonl(conn->advertised_as);
! 974: bgp_error(conn, 2, 2, (byte *) &val, 4);
! 975: }
! 976: else
! 977: bgp_error(conn, 2, 2, pkt+20, 2);
! 978:
! 979: return;
! 980: }
! 981:
! 982: /* Check the other connection */
! 983: other = (conn == &p->outgoing_conn) ? &p->incoming_conn : &p->outgoing_conn;
! 984: switch (other->state)
! 985: {
! 986: case BS_CONNECT:
! 987: case BS_ACTIVE:
! 988: /* Stop outgoing connection attempts */
! 989: bgp_conn_enter_idle_state(other);
! 990: break;
! 991:
! 992: case BS_IDLE:
! 993: case BS_OPENSENT:
! 994: case BS_CLOSE:
! 995: break;
! 996:
! 997: case BS_OPENCONFIRM:
! 998: /*
! 999: * Description of collision detection rules in RFC 4271 is confusing and
! 1000: * contradictory, but it is essentially:
! 1001: *
! 1002: * 1. Router with higher ID is dominant
! 1003: * 2. If both have the same ID, router with higher ASN is dominant [RFC6286]
! 1004: * 3. When both connections are in OpenConfirm state, one initiated by
! 1005: * the dominant router is kept.
! 1006: *
! 1007: * The first line in the expression below evaluates whether the neighbor
! 1008: * is dominant, the second line whether the new connection was initiated
! 1009: * by the neighbor. If both are true (or both are false), we keep the new
! 1010: * connection, otherwise we keep the old one.
! 1011: */
! 1012: if (((p->local_id < id) || ((p->local_id == id) && (p->local_as < p->remote_as)))
! 1013: == (conn == &p->incoming_conn))
! 1014: {
! 1015: /* Should close the other connection */
! 1016: BGP_TRACE(D_EVENTS, "Connection collision, giving up the other connection");
! 1017: bgp_error(other, 6, 7, NULL, 0);
! 1018: break;
! 1019: }
! 1020: /* Fall thru */
! 1021: case BS_ESTABLISHED:
! 1022: /* Should close this connection */
! 1023: BGP_TRACE(D_EVENTS, "Connection collision, giving up this connection");
! 1024: bgp_error(conn, 6, 7, NULL, 0);
! 1025: return;
! 1026: default:
! 1027: bug("bgp_rx_open: Unknown state");
! 1028: }
! 1029:
! 1030: /* Update our local variables */
! 1031: conn->hold_time = MIN(hold, p->cf->hold_time);
! 1032: conn->keepalive_time = p->cf->keepalive_time ? : conn->hold_time / 3;
! 1033: p->remote_id = id;
! 1034: p->as4_session = p->cf->enable_as4 && conn->peer_as4_support;
! 1035: p->add_path_rx = (p->cf->add_path & ADD_PATH_RX) && (conn->peer_add_path & ADD_PATH_TX);
! 1036: p->add_path_tx = (p->cf->add_path & ADD_PATH_TX) && (conn->peer_add_path & ADD_PATH_RX);
! 1037: p->gr_ready = p->cf->gr_mode && conn->peer_gr_able;
! 1038: p->ext_messages = p->cf->enable_extended_messages && conn->peer_ext_messages_support;
! 1039:
! 1040: if (p->add_path_tx)
! 1041: p->p.accept_ra_types = RA_ANY;
! 1042:
! 1043: DBG("BGP: Hold timer set to %d, keepalive to %d, AS to %d, ID to %x, AS4 session to %d\n", conn->hold_time, conn->keepalive_time, p->remote_as, p->remote_id, p->as4_session);
! 1044:
! 1045: bgp_schedule_packet(conn, PKT_KEEPALIVE);
! 1046: bgp_start_timer(conn->hold_timer, conn->hold_time);
! 1047: bgp_conn_enter_openconfirm_state(conn);
! 1048: }
! 1049:
! 1050:
! 1051: static inline void
! 1052: bgp_rx_end_mark(struct bgp_proto *p)
! 1053: {
! 1054: BGP_TRACE(D_PACKETS, "Got END-OF-RIB");
! 1055:
! 1056: if (p->load_state == BFS_LOADING)
! 1057: p->load_state = BFS_NONE;
! 1058:
! 1059: if (p->p.gr_recovery)
! 1060: proto_graceful_restart_unlock(&p->p);
! 1061:
! 1062: if (p->gr_active)
! 1063: bgp_graceful_restart_done(p);
! 1064: }
! 1065:
! 1066:
! 1067: #define DECODE_PREFIX(pp, ll) do { \
! 1068: if (p->add_path_rx) \
! 1069: { \
! 1070: if (ll < 5) { err=1; goto done; } \
! 1071: path_id = get_u32(pp); \
! 1072: pp += 4; \
! 1073: ll -= 4; \
! 1074: } \
! 1075: int b = *pp++; \
! 1076: int q; \
! 1077: ll--; \
! 1078: if (b > BITS_PER_IP_ADDRESS) { err=10; goto done; } \
! 1079: q = (b+7) / 8; \
! 1080: if (ll < q) { err=1; goto done; } \
! 1081: memcpy(&prefix, pp, q); \
! 1082: pp += q; \
! 1083: ll -= q; \
! 1084: ipa_ntoh(prefix); \
! 1085: prefix = ipa_and(prefix, ipa_mkmask(b)); \
! 1086: pxlen = b; \
! 1087: } while (0)
! 1088:
! 1089:
! 1090: static inline void
! 1091: bgp_rte_update(struct bgp_proto *p, ip_addr prefix, int pxlen,
! 1092: u32 path_id, u32 *last_id, struct rte_src **src,
! 1093: rta *a0, rta **a)
! 1094: {
! 1095: if (path_id != *last_id)
! 1096: {
! 1097: *src = rt_get_source(&p->p, path_id);
! 1098: *last_id = path_id;
! 1099:
! 1100: if (*a)
! 1101: {
! 1102: rta_free(*a);
! 1103: *a = NULL;
! 1104: }
! 1105: }
! 1106:
! 1107: /* Prepare cached route attributes */
! 1108: if (!*a)
! 1109: {
! 1110: a0->src = *src;
! 1111:
! 1112: /* Workaround for rta_lookup() breaking eattrs */
! 1113: ea_list *ea = a0->eattrs;
! 1114: *a = rta_lookup(a0);
! 1115: a0->eattrs = ea;
! 1116: }
! 1117:
! 1118: net *n = net_get(p->p.table, prefix, pxlen);
! 1119: rte *e = rte_get_temp(rta_clone(*a));
! 1120: e->net = n;
! 1121: e->pflags = 0;
! 1122: e->u.bgp.suppressed = 0;
! 1123: rte_update2(p->p.main_ahook, n, e, *src);
! 1124: }
! 1125:
! 1126: static inline void
! 1127: bgp_rte_withdraw(struct bgp_proto *p, ip_addr prefix, int pxlen,
! 1128: u32 path_id, u32 *last_id, struct rte_src **src)
! 1129: {
! 1130: if (path_id != *last_id)
! 1131: {
! 1132: *src = rt_find_source(&p->p, path_id);
! 1133: *last_id = path_id;
! 1134: }
! 1135:
! 1136: net *n = net_find(p->p.table, prefix, pxlen);
! 1137: rte_update2( p->p.main_ahook, n, NULL, *src);
! 1138: }
! 1139:
! 1140: static inline int
! 1141: bgp_set_next_hop(struct bgp_proto *p, rta *a)
! 1142: {
! 1143: struct eattr *nh = ea_find(a->eattrs, EA_CODE(EAP_BGP, BA_NEXT_HOP));
! 1144: ip_addr *nexthop = (ip_addr *) nh->u.ptr->data;
! 1145:
! 1146: #ifdef IPV6
! 1147: int second = (nh->u.ptr->length == NEXT_HOP_LENGTH) && ipa_nonzero(nexthop[1]);
! 1148:
! 1149: /* First address should not be link-local, but may be zero in direct mode */
! 1150: if (ipa_is_link_local(*nexthop))
! 1151: *nexthop = IPA_NONE;
! 1152: #else
! 1153: int second = 0;
! 1154: #endif
! 1155:
! 1156: if (p->cf->gw_mode == GW_DIRECT)
! 1157: {
! 1158: neighbor *ng = NULL;
! 1159:
! 1160: if (ipa_nonzero(*nexthop))
! 1161: ng = neigh_find(&p->p, nexthop, 0);
! 1162: else if (second) /* GW_DIRECT -> single_hop -> p->neigh != NULL */
! 1163: ng = neigh_find2(&p->p, nexthop + 1, p->neigh->iface, 0);
! 1164:
! 1165: /* Fallback */
! 1166: if (!ng)
! 1167: ng = p->neigh;
! 1168:
! 1169: if (ng->scope == SCOPE_HOST)
! 1170: return 0;
! 1171:
! 1172: a->dest = RTD_ROUTER;
! 1173: a->gw = ng->addr;
! 1174: a->iface = ng->iface;
! 1175: a->hostentry = NULL;
! 1176: a->igp_metric = 0;
! 1177: }
! 1178: else /* GW_RECURSIVE */
! 1179: {
! 1180: if (ipa_zero(*nexthop))
! 1181: return 0;
! 1182:
! 1183: rta_set_recursive_next_hop(p->p.table, a, p->igp_table, nexthop, nexthop + second);
! 1184: }
! 1185:
! 1186: return 1;
! 1187: }
! 1188:
! 1189: #ifndef IPV6 /* IPv4 version */
! 1190:
! 1191: static void
! 1192: bgp_do_rx_update(struct bgp_conn *conn,
! 1193: byte *withdrawn, int withdrawn_len,
! 1194: byte *nlri, int nlri_len,
! 1195: byte *attrs, int attr_len)
! 1196: {
! 1197: struct bgp_proto *p = conn->bgp;
! 1198: struct rte_src *src = p->p.main_source;
! 1199: rta *a0, *a = NULL;
! 1200: ip_addr prefix;
! 1201: int pxlen, err = 0;
! 1202: u32 path_id = 0;
! 1203: u32 last_id = 0;
! 1204:
! 1205: /* Check for End-of-RIB marker */
! 1206: if (!withdrawn_len && !attr_len && !nlri_len)
! 1207: {
! 1208: bgp_rx_end_mark(p);
! 1209: return;
! 1210: }
! 1211:
! 1212: /* Withdraw routes */
! 1213: while (withdrawn_len)
! 1214: {
! 1215: DECODE_PREFIX(withdrawn, withdrawn_len);
! 1216: DBG("Withdraw %I/%d\n", prefix, pxlen);
! 1217:
! 1218: bgp_rte_withdraw(p, prefix, pxlen, path_id, &last_id, &src);
! 1219: }
! 1220:
! 1221: if (!attr_len && !nlri_len) /* shortcut */
! 1222: return;
! 1223:
! 1224: a0 = bgp_decode_attrs(conn, attrs, attr_len, bgp_linpool, nlri_len);
! 1225:
! 1226: if (conn->state != BS_ESTABLISHED) /* fatal error during decoding */
! 1227: return;
! 1228:
! 1229: if (a0 && nlri_len && !bgp_set_next_hop(p, a0))
! 1230: a0 = NULL;
! 1231:
! 1232: last_id = 0;
! 1233: src = p->p.main_source;
! 1234:
! 1235: while (nlri_len)
! 1236: {
! 1237: DECODE_PREFIX(nlri, nlri_len);
! 1238: DBG("Add %I/%d\n", prefix, pxlen);
! 1239:
! 1240: if (a0)
! 1241: bgp_rte_update(p, prefix, pxlen, path_id, &last_id, &src, a0, &a);
! 1242: else /* Forced withdraw as a result of soft error */
! 1243: bgp_rte_withdraw(p, prefix, pxlen, path_id, &last_id, &src);
! 1244: }
! 1245:
! 1246: done:
! 1247: if (a)
! 1248: rta_free(a);
! 1249:
! 1250: if (err)
! 1251: bgp_error(conn, 3, err, NULL, 0);
! 1252:
! 1253: return;
! 1254: }
! 1255:
! 1256: #else /* IPv6 version */
! 1257:
! 1258: #define DO_NLRI(name) \
! 1259: x = p->name##_start; \
! 1260: len = len0 = p->name##_len; \
! 1261: if (len) \
! 1262: { \
! 1263: if (len < 3) { err=9; goto done; } \
! 1264: af = get_u16(x); \
! 1265: x += 3; \
! 1266: len -= 3; \
! 1267: DBG("\tNLRI AF=%d sub=%d len=%d\n", af, x[-1], len);\
! 1268: } \
! 1269: else \
! 1270: af = 0; \
! 1271: if (af == BGP_AF_IPV6)
! 1272:
! 1273: static void
! 1274: bgp_attach_next_hop(rta *a0, byte *x)
! 1275: {
! 1276: ip_addr *nh = (ip_addr *) bgp_attach_attr_wa(&a0->eattrs, bgp_linpool, BA_NEXT_HOP, NEXT_HOP_LENGTH);
! 1277: memcpy(nh, x+1, 16);
! 1278: ipa_ntoh(nh[0]);
! 1279:
! 1280: /* We store received link local address in the other part of BA_NEXT_HOP eattr. */
! 1281: if (*x == 32)
! 1282: {
! 1283: memcpy(nh+1, x+17, 16);
! 1284: ipa_ntoh(nh[1]);
! 1285: }
! 1286: else
! 1287: nh[1] = IPA_NONE;
! 1288: }
! 1289:
! 1290:
! 1291: static void
! 1292: bgp_do_rx_update(struct bgp_conn *conn,
! 1293: byte *withdrawn UNUSED, int withdrawn_len,
! 1294: byte *nlri UNUSED, int nlri_len,
! 1295: byte *attrs, int attr_len)
! 1296: {
! 1297: struct bgp_proto *p = conn->bgp;
! 1298: struct rte_src *src = p->p.main_source;
! 1299: byte *x;
! 1300: int len, len0;
! 1301: unsigned af;
! 1302: rta *a0, *a = NULL;
! 1303: ip_addr prefix;
! 1304: int pxlen, err = 0;
! 1305: u32 path_id = 0;
! 1306: u32 last_id = 0;
! 1307:
! 1308: p->mp_reach_len = 0;
! 1309: p->mp_unreach_len = 0;
! 1310: a0 = bgp_decode_attrs(conn, attrs, attr_len, bgp_linpool, 0);
! 1311:
! 1312: if (conn->state != BS_ESTABLISHED) /* fatal error during decoding */
! 1313: return;
! 1314:
! 1315: /* Check for End-of-RIB marker */
! 1316: if ((attr_len < 8) && !withdrawn_len && !nlri_len && !p->mp_reach_len &&
! 1317: (p->mp_unreach_len == 3) && (get_u16(p->mp_unreach_start) == BGP_AF_IPV6))
! 1318: {
! 1319: bgp_rx_end_mark(p);
! 1320: return;
! 1321: }
! 1322:
! 1323: DO_NLRI(mp_unreach)
! 1324: {
! 1325: while (len)
! 1326: {
! 1327: DECODE_PREFIX(x, len);
! 1328: DBG("Withdraw %I/%d\n", prefix, pxlen);
! 1329: bgp_rte_withdraw(p, prefix, pxlen, path_id, &last_id, &src);
! 1330: }
! 1331: }
! 1332:
! 1333: DO_NLRI(mp_reach)
! 1334: {
! 1335: /* Create fake NEXT_HOP attribute */
! 1336: if (len < 1 || (*x != 16 && *x != 32) || len < *x + 2)
! 1337: { err = 9; goto done; }
! 1338:
! 1339: if (a0)
! 1340: bgp_attach_next_hop(a0, x);
! 1341:
! 1342: /* Also ignore one reserved byte */
! 1343: len -= *x + 2;
! 1344: x += *x + 2;
! 1345:
! 1346: if (a0 && ! bgp_set_next_hop(p, a0))
! 1347: a0 = NULL;
! 1348:
! 1349: last_id = 0;
! 1350: src = p->p.main_source;
! 1351:
! 1352: while (len)
! 1353: {
! 1354: DECODE_PREFIX(x, len);
! 1355: DBG("Add %I/%d\n", prefix, pxlen);
! 1356:
! 1357: if (a0)
! 1358: bgp_rte_update(p, prefix, pxlen, path_id, &last_id, &src, a0, &a);
! 1359: else /* Forced withdraw as a result of soft error */
! 1360: bgp_rte_withdraw(p, prefix, pxlen, path_id, &last_id, &src);
! 1361: }
! 1362: }
! 1363:
! 1364: done:
! 1365: if (a)
! 1366: rta_free(a);
! 1367:
! 1368: if (err) /* Use subcode 9, not err */
! 1369: bgp_error(conn, 3, 9, NULL, 0);
! 1370:
! 1371: return;
! 1372: }
! 1373:
! 1374: #endif
! 1375:
! 1376: static void
! 1377: bgp_rx_update(struct bgp_conn *conn, byte *pkt, uint len)
! 1378: {
! 1379: struct bgp_proto *p = conn->bgp;
! 1380: byte *withdrawn, *attrs, *nlri;
! 1381: uint withdrawn_len, attr_len, nlri_len;
! 1382:
! 1383: BGP_TRACE_RL(&rl_rcv_update, D_PACKETS, "Got UPDATE");
! 1384:
! 1385: /* Workaround for some BGP implementations that skip initial KEEPALIVE */
! 1386: if (conn->state == BS_OPENCONFIRM)
! 1387: bgp_conn_enter_established_state(conn);
! 1388:
! 1389: if (conn->state != BS_ESTABLISHED)
! 1390: { bgp_error(conn, 5, fsm_err_subcode[conn->state], NULL, 0); return; }
! 1391: bgp_start_timer(conn->hold_timer, conn->hold_time);
! 1392:
! 1393: /* Find parts of the packet and check sizes */
! 1394: if (len < 23)
! 1395: {
! 1396: bgp_error(conn, 1, 2, pkt+16, 2);
! 1397: return;
! 1398: }
! 1399: withdrawn = pkt + 21;
! 1400: withdrawn_len = get_u16(pkt + 19);
! 1401: if (withdrawn_len + 23 > len)
! 1402: goto malformed;
! 1403: attrs = withdrawn + withdrawn_len + 2;
! 1404: attr_len = get_u16(attrs - 2);
! 1405: if (withdrawn_len + attr_len + 23 > len)
! 1406: goto malformed;
! 1407: nlri = attrs + attr_len;
! 1408: nlri_len = len - withdrawn_len - attr_len - 23;
! 1409: if (!attr_len && nlri_len)
! 1410: goto malformed;
! 1411: DBG("Sizes: withdrawn=%d, attrs=%d, NLRI=%d\n", withdrawn_len, attr_len, nlri_len);
! 1412:
! 1413: lp_flush(bgp_linpool);
! 1414:
! 1415: bgp_do_rx_update(conn, withdrawn, withdrawn_len, nlri, nlri_len, attrs, attr_len);
! 1416: return;
! 1417:
! 1418: malformed:
! 1419: bgp_error(conn, 3, 1, NULL, 0);
! 1420: }
! 1421:
! 1422: static struct {
! 1423: byte major, minor;
! 1424: byte *msg;
! 1425: } bgp_msg_table[] = {
! 1426: { 1, 0, "Invalid message header" },
! 1427: { 1, 1, "Connection not synchronized" },
! 1428: { 1, 2, "Bad message length" },
! 1429: { 1, 3, "Bad message type" },
! 1430: { 2, 0, "Invalid OPEN message" },
! 1431: { 2, 1, "Unsupported version number" },
! 1432: { 2, 2, "Bad peer AS" },
! 1433: { 2, 3, "Bad BGP identifier" },
! 1434: { 2, 4, "Unsupported optional parameter" },
! 1435: { 2, 5, "Authentication failure" },
! 1436: { 2, 6, "Unacceptable hold time" },
! 1437: { 2, 7, "Required capability missing" }, /* [RFC5492] */
! 1438: { 2, 8, "No supported AFI/SAFI" }, /* This error msg is nonstandard */
! 1439: { 3, 0, "Invalid UPDATE message" },
! 1440: { 3, 1, "Malformed attribute list" },
! 1441: { 3, 2, "Unrecognized well-known attribute" },
! 1442: { 3, 3, "Missing mandatory attribute" },
! 1443: { 3, 4, "Invalid attribute flags" },
! 1444: { 3, 5, "Invalid attribute length" },
! 1445: { 3, 6, "Invalid ORIGIN attribute" },
! 1446: { 3, 7, "AS routing loop" }, /* Deprecated */
! 1447: { 3, 8, "Invalid NEXT_HOP attribute" },
! 1448: { 3, 9, "Optional attribute error" },
! 1449: { 3, 10, "Invalid network field" },
! 1450: { 3, 11, "Malformed AS_PATH" },
! 1451: { 4, 0, "Hold timer expired" },
! 1452: { 5, 0, "Finite state machine error" }, /* Subcodes are according to [RFC6608] */
! 1453: { 5, 1, "Unexpected message in OpenSent state" },
! 1454: { 5, 2, "Unexpected message in OpenConfirm state" },
! 1455: { 5, 3, "Unexpected message in Established state" },
! 1456: { 6, 0, "Cease" }, /* Subcodes are according to [RFC4486] */
! 1457: { 6, 1, "Maximum number of prefixes reached" },
! 1458: { 6, 2, "Administrative shutdown" },
! 1459: { 6, 3, "Peer de-configured" },
! 1460: { 6, 4, "Administrative reset" },
! 1461: { 6, 5, "Connection rejected" },
! 1462: { 6, 6, "Other configuration change" },
! 1463: { 6, 7, "Connection collision resolution" },
! 1464: { 6, 8, "Out of Resources" },
! 1465: { 7, 0, "Invalid ROUTE-REFRESH message" }, /* [RFC7313] */
! 1466: { 7, 1, "Invalid ROUTE-REFRESH message length" } /* [RFC7313] */
! 1467: };
! 1468:
! 1469: /**
! 1470: * bgp_error_dsc - return BGP error description
! 1471: * @code: BGP error code
! 1472: * @subcode: BGP error subcode
! 1473: *
! 1474: * bgp_error_dsc() returns error description for BGP errors
! 1475: * which might be static string or given temporary buffer.
! 1476: */
! 1477: const char *
! 1478: bgp_error_dsc(unsigned code, unsigned subcode)
! 1479: {
! 1480: static char buff[32];
! 1481: unsigned i;
! 1482: for (i=0; i < ARRAY_SIZE(bgp_msg_table); i++)
! 1483: if (bgp_msg_table[i].major == code && bgp_msg_table[i].minor == subcode)
! 1484: {
! 1485: return bgp_msg_table[i].msg;
! 1486: }
! 1487:
! 1488: bsprintf(buff, "Unknown error %d.%d", code, subcode);
! 1489: return buff;
! 1490: }
! 1491:
! 1492: void
! 1493: bgp_log_error(struct bgp_proto *p, u8 class, char *msg, unsigned code, unsigned subcode, byte *data, unsigned len)
! 1494: {
! 1495: const byte *name;
! 1496: byte *t, argbuf[36];
! 1497: unsigned i;
! 1498:
! 1499: /* Don't report Cease messages generated by myself */
! 1500: if (code == 6 && class == BE_BGP_TX)
! 1501: return;
! 1502:
! 1503: name = bgp_error_dsc(code, subcode);
! 1504: t = argbuf;
! 1505: if (len)
! 1506: {
! 1507: *t++ = ':';
! 1508: *t++ = ' ';
! 1509:
! 1510: if ((code == 2) && (subcode == 2) && ((len == 2) || (len == 4)))
! 1511: {
! 1512: /* Bad peer AS - we would like to print the AS */
! 1513: t += bsprintf(t, "%d", (len == 2) ? get_u16(data) : get_u32(data));
! 1514: goto done;
! 1515: }
! 1516: if (len > 16)
! 1517: len = 16;
! 1518: for (i=0; i<len; i++)
! 1519: t += bsprintf(t, "%02x", data[i]);
! 1520: }
! 1521: done:
! 1522: *t = 0;
! 1523: log(L_REMOTE "%s: %s: %s%s", p->p.name, msg, name, argbuf);
! 1524: }
! 1525:
! 1526: static void
! 1527: bgp_rx_notification(struct bgp_conn *conn, byte *pkt, uint len)
! 1528: {
! 1529: struct bgp_proto *p = conn->bgp;
! 1530: if (len < 21)
! 1531: {
! 1532: bgp_error(conn, 1, 2, pkt+16, 2);
! 1533: return;
! 1534: }
! 1535:
! 1536: unsigned code = pkt[19];
! 1537: unsigned subcode = pkt[20];
! 1538: int err = (code != 6);
! 1539:
! 1540: bgp_log_error(p, BE_BGP_RX, "Received", code, subcode, pkt+21, len-21);
! 1541: bgp_store_error(p, conn, BE_BGP_RX, (code << 16) | subcode);
! 1542:
! 1543: #ifndef IPV6
! 1544: if ((code == 2) && ((subcode == 4) || (subcode == 7))
! 1545: /* Error related to capability:
! 1546: * 4 - Peer does not support capabilities at all.
! 1547: * 7 - Peer request some capability. Strange unless it is IPv6 only peer.
! 1548: */
! 1549: && (p->cf->capabilities == 2)
! 1550: /* Capabilities are not explicitly enabled or disabled, therefore heuristic is used */
! 1551: && (conn->start_state == BSS_CONNECT)
! 1552: /* Failed connection attempt have used capabilities */
! 1553: && (p->cf->remote_as <= 0xFFFF))
! 1554: /* Not possible with disabled capabilities */
! 1555: {
! 1556: /* We try connect without capabilities */
! 1557: log(L_WARN "%s: Capability related error received, retry with capabilities disabled", p->p.name);
! 1558: p->start_state = BSS_CONNECT_NOCAP;
! 1559: err = 0;
! 1560: }
! 1561: #endif
! 1562:
! 1563: bgp_conn_enter_close_state(conn);
! 1564: bgp_schedule_packet(conn, PKT_SCHEDULE_CLOSE);
! 1565:
! 1566: if (err)
! 1567: {
! 1568: bgp_update_startup_delay(p);
! 1569: bgp_stop(p, 0);
! 1570: }
! 1571: }
! 1572:
! 1573: static void
! 1574: bgp_rx_keepalive(struct bgp_conn *conn)
! 1575: {
! 1576: struct bgp_proto *p = conn->bgp;
! 1577:
! 1578: BGP_TRACE(D_PACKETS, "Got KEEPALIVE");
! 1579: bgp_start_timer(conn->hold_timer, conn->hold_time);
! 1580: switch (conn->state)
! 1581: {
! 1582: case BS_OPENCONFIRM:
! 1583: bgp_conn_enter_established_state(conn);
! 1584: break;
! 1585: case BS_ESTABLISHED:
! 1586: break;
! 1587: default:
! 1588: bgp_error(conn, 5, fsm_err_subcode[conn->state], NULL, 0);
! 1589: }
! 1590: }
! 1591:
! 1592: static void
! 1593: bgp_rx_route_refresh(struct bgp_conn *conn, byte *pkt, uint len)
! 1594: {
! 1595: struct bgp_proto *p = conn->bgp;
! 1596:
! 1597: if (conn->state != BS_ESTABLISHED)
! 1598: { bgp_error(conn, 5, fsm_err_subcode[conn->state], NULL, 0); return; }
! 1599:
! 1600: if (!p->cf->enable_refresh)
! 1601: { bgp_error(conn, 1, 3, pkt+18, 1); return; }
! 1602:
! 1603: if (len < (BGP_HEADER_LENGTH + 4))
! 1604: { bgp_error(conn, 1, 2, pkt+16, 2); return; }
! 1605:
! 1606: if (len > (BGP_HEADER_LENGTH + 4))
! 1607: { bgp_error(conn, 7, 1, pkt, MIN(len, 2048)); return; }
! 1608:
! 1609: /* FIXME - we ignore AFI/SAFI values, as we support
! 1610: just one value and even an error code for an invalid
! 1611: request is not defined */
! 1612:
! 1613: /* RFC 7313 redefined reserved field as RR message subtype */
! 1614: uint subtype = conn->peer_enhanced_refresh_support ? pkt[21] : BGP_RR_REQUEST;
! 1615:
! 1616: switch (subtype)
! 1617: {
! 1618: case BGP_RR_REQUEST:
! 1619: BGP_TRACE(D_PACKETS, "Got ROUTE-REFRESH");
! 1620: proto_request_feeding(&p->p);
! 1621: break;
! 1622:
! 1623: case BGP_RR_BEGIN:
! 1624: BGP_TRACE(D_PACKETS, "Got BEGIN-OF-RR");
! 1625: bgp_refresh_begin(p);
! 1626: break;
! 1627:
! 1628: case BGP_RR_END:
! 1629: BGP_TRACE(D_PACKETS, "Got END-OF-RR");
! 1630: bgp_refresh_end(p);
! 1631: break;
! 1632:
! 1633: default:
! 1634: log(L_WARN "%s: Got ROUTE-REFRESH message with unknown subtype %u, ignoring",
! 1635: p->p.name, subtype);
! 1636: break;
! 1637: }
! 1638: }
! 1639:
! 1640:
! 1641: /**
! 1642: * bgp_rx_packet - handle a received packet
! 1643: * @conn: BGP connection
! 1644: * @pkt: start of the packet
! 1645: * @len: packet size
! 1646: *
! 1647: * bgp_rx_packet() takes a newly received packet and calls the corresponding
! 1648: * packet handler according to the packet type.
! 1649: */
! 1650: static void
! 1651: bgp_rx_packet(struct bgp_conn *conn, byte *pkt, unsigned len)
! 1652: {
! 1653: byte type = pkt[18];
! 1654:
! 1655: DBG("BGP: Got packet %02x (%d bytes)\n", type, len);
! 1656:
! 1657: if (conn->bgp->p.mrtdump & MD_MESSAGES)
! 1658: mrt_dump_bgp_packet(conn, pkt, len);
! 1659:
! 1660: switch (type)
! 1661: {
! 1662: case PKT_OPEN: return bgp_rx_open(conn, pkt, len);
! 1663: case PKT_UPDATE: return bgp_rx_update(conn, pkt, len);
! 1664: case PKT_NOTIFICATION: return bgp_rx_notification(conn, pkt, len);
! 1665: case PKT_KEEPALIVE: return bgp_rx_keepalive(conn);
! 1666: case PKT_ROUTE_REFRESH: return bgp_rx_route_refresh(conn, pkt, len);
! 1667: default: bgp_error(conn, 1, 3, pkt+18, 1);
! 1668: }
! 1669: }
! 1670:
! 1671: /**
! 1672: * bgp_rx - handle received data
! 1673: * @sk: socket
! 1674: * @size: amount of data received
! 1675: *
! 1676: * bgp_rx() is called by the socket layer whenever new data arrive from
! 1677: * the underlying TCP connection. It assembles the data fragments to packets,
! 1678: * checks their headers and framing and passes complete packets to
! 1679: * bgp_rx_packet().
! 1680: */
! 1681: int
! 1682: bgp_rx(sock *sk, uint size)
! 1683: {
! 1684: struct bgp_conn *conn = sk->data;
! 1685: struct bgp_proto *p = conn->bgp;
! 1686: byte *pkt_start = sk->rbuf;
! 1687: byte *end = pkt_start + size;
! 1688: unsigned i, len;
! 1689:
! 1690: DBG("BGP: RX hook: Got %d bytes\n", size);
! 1691: while (end >= pkt_start + BGP_HEADER_LENGTH)
! 1692: {
! 1693: if ((conn->state == BS_CLOSE) || (conn->sk != sk))
! 1694: return 0;
! 1695: for(i=0; i<16; i++)
! 1696: if (pkt_start[i] != 0xff)
! 1697: {
! 1698: bgp_error(conn, 1, 1, NULL, 0);
! 1699: break;
! 1700: }
! 1701: len = get_u16(pkt_start+16);
! 1702: if (len < BGP_HEADER_LENGTH || len > bgp_max_packet_length(p))
! 1703: {
! 1704: bgp_error(conn, 1, 2, pkt_start+16, 2);
! 1705: break;
! 1706: }
! 1707: if (end < pkt_start + len)
! 1708: break;
! 1709: bgp_rx_packet(conn, pkt_start, len);
! 1710: pkt_start += len;
! 1711: }
! 1712: if (pkt_start != sk->rbuf)
! 1713: {
! 1714: memmove(sk->rbuf, pkt_start, end - pkt_start);
! 1715: sk->rpos = sk->rbuf + (end - pkt_start);
! 1716: }
! 1717: return 0;
! 1718: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to packets.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird / proto / bgp