Annotation of embedaddon/quagga/bgpd/bgp_packet.c, revision 1.1.1.1
1.1 misho 1: /* BGP packet management routine.
2: Copyright (C) 1999 Kunihiro Ishiguro
3:
4: This file is part of GNU Zebra.
5:
6: GNU Zebra is free software; you can redistribute it and/or modify it
7: under the terms of the GNU General Public License as published by the
8: Free Software Foundation; either version 2, or (at your option) any
9: later version.
10:
11: GNU Zebra is distributed in the hope that it will be useful, but
12: WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14: General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU Zebra; see the file COPYING. If not, write to the Free
18: Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19: 02111-1307, USA. */
20:
21: #include <zebra.h>
22:
23: #include "thread.h"
24: #include "stream.h"
25: #include "network.h"
26: #include "prefix.h"
27: #include "command.h"
28: #include "log.h"
29: #include "memory.h"
30: #include "sockunion.h" /* for inet_ntop () */
31: #include "linklist.h"
32: #include "plist.h"
33:
34: #include "bgpd/bgpd.h"
35: #include "bgpd/bgp_table.h"
36: #include "bgpd/bgp_dump.h"
37: #include "bgpd/bgp_attr.h"
38: #include "bgpd/bgp_debug.h"
39: #include "bgpd/bgp_fsm.h"
40: #include "bgpd/bgp_route.h"
41: #include "bgpd/bgp_packet.h"
42: #include "bgpd/bgp_open.h"
43: #include "bgpd/bgp_aspath.h"
44: #include "bgpd/bgp_community.h"
45: #include "bgpd/bgp_ecommunity.h"
46: #include "bgpd/bgp_network.h"
47: #include "bgpd/bgp_mplsvpn.h"
48: #include "bgpd/bgp_advertise.h"
49: #include "bgpd/bgp_vty.h"
50:
51: int stream_put_prefix (struct stream *, struct prefix *);
52:
53: /* Set up BGP packet marker and packet type. */
54: static int
55: bgp_packet_set_marker (struct stream *s, u_char type)
56: {
57: int i;
58:
59: /* Fill in marker. */
60: for (i = 0; i < BGP_MARKER_SIZE; i++)
61: stream_putc (s, 0xff);
62:
63: /* Dummy total length. This field is should be filled in later on. */
64: stream_putw (s, 0);
65:
66: /* BGP packet type. */
67: stream_putc (s, type);
68:
69: /* Return current stream size. */
70: return stream_get_endp (s);
71: }
72:
73: /* Set BGP packet header size entry. If size is zero then use current
74: stream size. */
75: static int
76: bgp_packet_set_size (struct stream *s)
77: {
78: int cp;
79:
80: /* Preserve current pointer. */
81: cp = stream_get_endp (s);
82: stream_putw_at (s, BGP_MARKER_SIZE, cp);
83:
84: return cp;
85: }
86:
87: /* Add new packet to the peer. */
88: static void
89: bgp_packet_add (struct peer *peer, struct stream *s)
90: {
91: /* Add packet to the end of list. */
92: stream_fifo_push (peer->obuf, s);
93: }
94:
95: /* Free first packet. */
96: static void
97: bgp_packet_delete (struct peer *peer)
98: {
99: stream_free (stream_fifo_pop (peer->obuf));
100: }
101:
102: /* Check file descriptor whether connect is established. */
103: static void
104: bgp_connect_check (struct peer *peer)
105: {
106: int status;
107: socklen_t slen;
108: int ret;
109:
110: /* Anyway I have to reset read and write thread. */
111: BGP_READ_OFF (peer->t_read);
112: BGP_WRITE_OFF (peer->t_write);
113:
114: /* Check file descriptor. */
115: slen = sizeof (status);
116: ret = getsockopt(peer->fd, SOL_SOCKET, SO_ERROR, (void *) &status, &slen);
117:
118: /* If getsockopt is fail, this is fatal error. */
119: if (ret < 0)
120: {
121: zlog (peer->log, LOG_INFO, "can't get sockopt for nonblocking connect");
122: BGP_EVENT_ADD (peer, TCP_fatal_error);
123: return;
124: }
125:
126: /* When status is 0 then TCP connection is established. */
127: if (status == 0)
128: {
129: BGP_EVENT_ADD (peer, TCP_connection_open);
130: }
131: else
132: {
133: if (BGP_DEBUG (events, EVENTS))
134: plog_debug (peer->log, "%s [Event] Connect failed (%s)",
135: peer->host, safe_strerror (errno));
136: BGP_EVENT_ADD (peer, TCP_connection_open_failed);
137: }
138: }
139:
140: /* Make BGP update packet. */
141: static struct stream *
142: bgp_update_packet (struct peer *peer, afi_t afi, safi_t safi)
143: {
144: struct stream *s;
145: struct bgp_adj_out *adj;
146: struct bgp_advertise *adv;
147: struct stream *packet;
148: struct bgp_node *rn = NULL;
149: struct bgp_info *binfo = NULL;
150: bgp_size_t total_attr_len = 0;
151: unsigned long pos;
152: char buf[BUFSIZ];
153:
154: s = peer->work;
155: stream_reset (s);
156:
157: adv = FIFO_HEAD (&peer->sync[afi][safi]->update);
158:
159: while (adv)
160: {
161: assert (adv->rn);
162: rn = adv->rn;
163: adj = adv->adj;
164: if (adv->binfo)
165: binfo = adv->binfo;
166:
167: /* When remaining space can't include NLRI and it's length. */
168: if (STREAM_REMAIN (s) <= BGP_NLRI_LENGTH + PSIZE (rn->p.prefixlen))
169: break;
170:
171: /* If packet is empty, set attribute. */
172: if (stream_empty (s))
173: {
174: struct prefix_rd *prd = NULL;
175: u_char *tag = NULL;
176: struct peer *from = NULL;
177:
178: if (rn->prn)
179: prd = (struct prefix_rd *) &rn->prn->p;
180: if (binfo)
181: {
182: from = binfo->peer;
183: if (binfo->extra)
184: tag = binfo->extra->tag;
185: }
186:
187: bgp_packet_set_marker (s, BGP_MSG_UPDATE);
188: stream_putw (s, 0);
189: pos = stream_get_endp (s);
190: stream_putw (s, 0);
191: total_attr_len = bgp_packet_attribute (NULL, peer, s,
192: adv->baa->attr,
193: &rn->p, afi, safi,
194: from, prd, tag);
195: stream_putw_at (s, pos, total_attr_len);
196: }
197:
198: if (afi == AFI_IP && safi == SAFI_UNICAST)
199: stream_put_prefix (s, &rn->p);
200:
201: if (BGP_DEBUG (update, UPDATE_OUT))
202: zlog (peer->log, LOG_DEBUG, "%s send UPDATE %s/%d",
203: peer->host,
204: inet_ntop (rn->p.family, &(rn->p.u.prefix), buf, BUFSIZ),
205: rn->p.prefixlen);
206:
207: /* Synchnorize attribute. */
208: if (adj->attr)
209: bgp_attr_unintern (&adj->attr);
210: else
211: peer->scount[afi][safi]++;
212:
213: adj->attr = bgp_attr_intern (adv->baa->attr);
214:
215: adv = bgp_advertise_clean (peer, adj, afi, safi);
216:
217: if (! (afi == AFI_IP && safi == SAFI_UNICAST))
218: break;
219: }
220:
221: if (! stream_empty (s))
222: {
223: bgp_packet_set_size (s);
224: packet = stream_dup (s);
225: bgp_packet_add (peer, packet);
226: BGP_WRITE_ON (peer->t_write, bgp_write, peer->fd);
227: stream_reset (s);
228: return packet;
229: }
230: return NULL;
231: }
232:
233: static struct stream *
234: bgp_update_packet_eor (struct peer *peer, afi_t afi, safi_t safi)
235: {
236: struct stream *s;
237: struct stream *packet;
238:
239: if (DISABLE_BGP_ANNOUNCE)
240: return NULL;
241:
242: if (BGP_DEBUG (normal, NORMAL))
243: zlog_debug ("send End-of-RIB for %s to %s", afi_safi_print (afi, safi), peer->host);
244:
245: s = stream_new (BGP_MAX_PACKET_SIZE);
246:
247: /* Make BGP update packet. */
248: bgp_packet_set_marker (s, BGP_MSG_UPDATE);
249:
250: /* Unfeasible Routes Length */
251: stream_putw (s, 0);
252:
253: if (afi == AFI_IP && safi == SAFI_UNICAST)
254: {
255: /* Total Path Attribute Length */
256: stream_putw (s, 0);
257: }
258: else
259: {
260: /* Total Path Attribute Length */
261: stream_putw (s, 6);
262: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
263: stream_putc (s, BGP_ATTR_MP_UNREACH_NLRI);
264: stream_putc (s, 3);
265: stream_putw (s, afi);
266: stream_putc (s, safi);
267: }
268:
269: bgp_packet_set_size (s);
270: packet = stream_dup (s);
271: bgp_packet_add (peer, packet);
272: stream_free (s);
273: return packet;
274: }
275:
276: /* Make BGP withdraw packet. */
277: static struct stream *
278: bgp_withdraw_packet (struct peer *peer, afi_t afi, safi_t safi)
279: {
280: struct stream *s;
281: struct stream *packet;
282: struct bgp_adj_out *adj;
283: struct bgp_advertise *adv;
284: struct bgp_node *rn;
285: unsigned long pos;
286: bgp_size_t unfeasible_len;
287: bgp_size_t total_attr_len;
288: char buf[BUFSIZ];
289:
290: s = peer->work;
291: stream_reset (s);
292:
293: while ((adv = FIFO_HEAD (&peer->sync[afi][safi]->withdraw)) != NULL)
294: {
295: assert (adv->rn);
296: adj = adv->adj;
297: rn = adv->rn;
298:
299: if (STREAM_REMAIN (s)
300: < (BGP_NLRI_LENGTH + BGP_TOTAL_ATTR_LEN + PSIZE (rn->p.prefixlen)))
301: break;
302:
303: if (stream_empty (s))
304: {
305: bgp_packet_set_marker (s, BGP_MSG_UPDATE);
306: stream_putw (s, 0);
307: }
308:
309: if (afi == AFI_IP && safi == SAFI_UNICAST)
310: stream_put_prefix (s, &rn->p);
311: else
312: {
313: struct prefix_rd *prd = NULL;
314:
315: if (rn->prn)
316: prd = (struct prefix_rd *) &rn->prn->p;
317: pos = stream_get_endp (s);
318: stream_putw (s, 0);
319: total_attr_len
320: = bgp_packet_withdraw (peer, s, &rn->p, afi, safi, prd, NULL);
321:
322: /* Set total path attribute length. */
323: stream_putw_at (s, pos, total_attr_len);
324: }
325:
326: if (BGP_DEBUG (update, UPDATE_OUT))
327: zlog (peer->log, LOG_DEBUG, "%s send UPDATE %s/%d -- unreachable",
328: peer->host,
329: inet_ntop (rn->p.family, &(rn->p.u.prefix), buf, BUFSIZ),
330: rn->p.prefixlen);
331:
332: peer->scount[afi][safi]--;
333:
334: bgp_adj_out_remove (rn, adj, peer, afi, safi);
335: bgp_unlock_node (rn);
336:
337: if (! (afi == AFI_IP && safi == SAFI_UNICAST))
338: break;
339: }
340:
341: if (! stream_empty (s))
342: {
343: if (afi == AFI_IP && safi == SAFI_UNICAST)
344: {
345: unfeasible_len
346: = stream_get_endp (s) - BGP_HEADER_SIZE - BGP_UNFEASIBLE_LEN;
347: stream_putw_at (s, BGP_HEADER_SIZE, unfeasible_len);
348: stream_putw (s, 0);
349: }
350: bgp_packet_set_size (s);
351: packet = stream_dup (s);
352: bgp_packet_add (peer, packet);
353: stream_reset (s);
354: return packet;
355: }
356:
357: return NULL;
358: }
359:
360: void
361: bgp_default_update_send (struct peer *peer, struct attr *attr,
362: afi_t afi, safi_t safi, struct peer *from)
363: {
364: struct stream *s;
365: struct stream *packet;
366: struct prefix p;
367: unsigned long pos;
368: bgp_size_t total_attr_len;
369: char attrstr[BUFSIZ];
370: char buf[BUFSIZ];
371:
372: if (DISABLE_BGP_ANNOUNCE)
373: return;
374:
375: if (afi == AFI_IP)
376: str2prefix ("0.0.0.0/0", &p);
377: #ifdef HAVE_IPV6
378: else
379: str2prefix ("::/0", &p);
380: #endif /* HAVE_IPV6 */
381:
382: /* Logging the attribute. */
383: if (BGP_DEBUG (update, UPDATE_OUT))
384: {
385: bgp_dump_attr (peer, attr, attrstr, BUFSIZ);
386: zlog (peer->log, LOG_DEBUG, "%s send UPDATE %s/%d %s",
387: peer->host, inet_ntop(p.family, &(p.u.prefix), buf, BUFSIZ),
388: p.prefixlen, attrstr);
389: }
390:
391: s = stream_new (BGP_MAX_PACKET_SIZE);
392:
393: /* Make BGP update packet. */
394: bgp_packet_set_marker (s, BGP_MSG_UPDATE);
395:
396: /* Unfeasible Routes Length. */
397: stream_putw (s, 0);
398:
399: /* Make place for total attribute length. */
400: pos = stream_get_endp (s);
401: stream_putw (s, 0);
402: total_attr_len = bgp_packet_attribute (NULL, peer, s, attr, &p, afi, safi, from, NULL, NULL);
403:
404: /* Set Total Path Attribute Length. */
405: stream_putw_at (s, pos, total_attr_len);
406:
407: /* NLRI set. */
408: if (p.family == AF_INET && safi == SAFI_UNICAST)
409: stream_put_prefix (s, &p);
410:
411: /* Set size. */
412: bgp_packet_set_size (s);
413:
414: packet = stream_dup (s);
415: stream_free (s);
416:
417: /* Dump packet if debug option is set. */
418: #ifdef DEBUG
419: /* bgp_packet_dump (packet); */
420: #endif /* DEBUG */
421:
422: /* Add packet to the peer. */
423: bgp_packet_add (peer, packet);
424:
425: BGP_WRITE_ON (peer->t_write, bgp_write, peer->fd);
426: }
427:
428: void
429: bgp_default_withdraw_send (struct peer *peer, afi_t afi, safi_t safi)
430: {
431: struct stream *s;
432: struct stream *packet;
433: struct prefix p;
434: unsigned long pos;
435: unsigned long cp;
436: bgp_size_t unfeasible_len;
437: bgp_size_t total_attr_len;
438: char buf[BUFSIZ];
439:
440: if (DISABLE_BGP_ANNOUNCE)
441: return;
442:
443: if (afi == AFI_IP)
444: str2prefix ("0.0.0.0/0", &p);
445: #ifdef HAVE_IPV6
446: else
447: str2prefix ("::/0", &p);
448: #endif /* HAVE_IPV6 */
449:
450: total_attr_len = 0;
451: pos = 0;
452:
453: if (BGP_DEBUG (update, UPDATE_OUT))
454: zlog (peer->log, LOG_DEBUG, "%s send UPDATE %s/%d -- unreachable",
455: peer->host, inet_ntop(p.family, &(p.u.prefix), buf, BUFSIZ),
456: p.prefixlen);
457:
458: s = stream_new (BGP_MAX_PACKET_SIZE);
459:
460: /* Make BGP update packet. */
461: bgp_packet_set_marker (s, BGP_MSG_UPDATE);
462:
463: /* Unfeasible Routes Length. */;
464: cp = stream_get_endp (s);
465: stream_putw (s, 0);
466:
467: /* Withdrawn Routes. */
468: if (p.family == AF_INET && safi == SAFI_UNICAST)
469: {
470: stream_put_prefix (s, &p);
471:
472: unfeasible_len = stream_get_endp (s) - cp - 2;
473:
474: /* Set unfeasible len. */
475: stream_putw_at (s, cp, unfeasible_len);
476:
477: /* Set total path attribute length. */
478: stream_putw (s, 0);
479: }
480: else
481: {
482: pos = stream_get_endp (s);
483: stream_putw (s, 0);
484: total_attr_len = bgp_packet_withdraw (peer, s, &p, afi, safi, NULL, NULL);
485:
486: /* Set total path attribute length. */
487: stream_putw_at (s, pos, total_attr_len);
488: }
489:
490: bgp_packet_set_size (s);
491:
492: packet = stream_dup (s);
493: stream_free (s);
494:
495: /* Add packet to the peer. */
496: bgp_packet_add (peer, packet);
497:
498: BGP_WRITE_ON (peer->t_write, bgp_write, peer->fd);
499: }
500:
501: /* Get next packet to be written. */
502: static struct stream *
503: bgp_write_packet (struct peer *peer)
504: {
505: afi_t afi;
506: safi_t safi;
507: struct stream *s = NULL;
508: struct bgp_advertise *adv;
509:
510: s = stream_fifo_head (peer->obuf);
511: if (s)
512: return s;
513:
514: for (afi = AFI_IP; afi < AFI_MAX; afi++)
515: for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
516: {
517: adv = FIFO_HEAD (&peer->sync[afi][safi]->withdraw);
518: if (adv)
519: {
520: s = bgp_withdraw_packet (peer, afi, safi);
521: if (s)
522: return s;
523: }
524: }
525:
526: for (afi = AFI_IP; afi < AFI_MAX; afi++)
527: for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
528: {
529: adv = FIFO_HEAD (&peer->sync[afi][safi]->update);
530: if (adv)
531: {
532: if (adv->binfo && adv->binfo->uptime < peer->synctime)
533: {
534: if (CHECK_FLAG (adv->binfo->peer->cap, PEER_CAP_RESTART_RCV)
535: && CHECK_FLAG (adv->binfo->peer->cap, PEER_CAP_RESTART_ADV)
536: && ! CHECK_FLAG (adv->binfo->flags, BGP_INFO_STALE)
537: && safi != SAFI_MPLS_VPN)
538: {
539: if (CHECK_FLAG (adv->binfo->peer->af_sflags[afi][safi],
540: PEER_STATUS_EOR_RECEIVED))
541: s = bgp_update_packet (peer, afi, safi);
542: }
543: else
544: s = bgp_update_packet (peer, afi, safi);
545: }
546:
547: if (s)
548: return s;
549: }
550:
551: if (CHECK_FLAG (peer->cap, PEER_CAP_RESTART_RCV))
552: {
553: if (peer->afc_nego[afi][safi] && peer->synctime
554: && ! CHECK_FLAG (peer->af_sflags[afi][safi], PEER_STATUS_EOR_SEND)
555: && safi != SAFI_MPLS_VPN)
556: {
557: SET_FLAG (peer->af_sflags[afi][safi], PEER_STATUS_EOR_SEND);
558: return bgp_update_packet_eor (peer, afi, safi);
559: }
560: }
561: }
562:
563: return NULL;
564: }
565:
566: /* Is there partially written packet or updates we can send right
567: now. */
568: static int
569: bgp_write_proceed (struct peer *peer)
570: {
571: afi_t afi;
572: safi_t safi;
573: struct bgp_advertise *adv;
574:
575: if (stream_fifo_head (peer->obuf))
576: return 1;
577:
578: for (afi = AFI_IP; afi < AFI_MAX; afi++)
579: for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
580: if (FIFO_HEAD (&peer->sync[afi][safi]->withdraw))
581: return 1;
582:
583: for (afi = AFI_IP; afi < AFI_MAX; afi++)
584: for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
585: if ((adv = FIFO_HEAD (&peer->sync[afi][safi]->update)) != NULL)
586: if (adv->binfo->uptime < peer->synctime)
587: return 1;
588:
589: return 0;
590: }
591:
592: /* Write packet to the peer. */
593: int
594: bgp_write (struct thread *thread)
595: {
596: struct peer *peer;
597: u_char type;
598: struct stream *s;
599: int num;
600: unsigned int count = 0;
601:
602: /* Yes first of all get peer pointer. */
603: peer = THREAD_ARG (thread);
604: peer->t_write = NULL;
605:
606: /* For non-blocking IO check. */
607: if (peer->status == Connect)
608: {
609: bgp_connect_check (peer);
610: return 0;
611: }
612:
613: s = bgp_write_packet (peer);
614: if (!s)
615: return 0; /* nothing to send */
616:
617: sockopt_cork (peer->fd, 1);
618:
619: /* Nonblocking write until TCP output buffer is full. */
620: do
621: {
622: int writenum;
623:
624: /* Number of bytes to be sent. */
625: writenum = stream_get_endp (s) - stream_get_getp (s);
626:
627: /* Call write() system call. */
628: num = write (peer->fd, STREAM_PNT (s), writenum);
629: if (num < 0)
630: {
631: /* write failed either retry needed or error */
632: if (ERRNO_IO_RETRY(errno))
633: break;
634:
635: BGP_EVENT_ADD (peer, TCP_fatal_error);
636: return 0;
637: }
638:
639: if (num != writenum)
640: {
641: /* Partial write */
642: stream_forward_getp (s, num);
643: break;
644: }
645:
646: /* Retrieve BGP packet type. */
647: stream_set_getp (s, BGP_MARKER_SIZE + 2);
648: type = stream_getc (s);
649:
650: switch (type)
651: {
652: case BGP_MSG_OPEN:
653: peer->open_out++;
654: break;
655: case BGP_MSG_UPDATE:
656: peer->update_out++;
657: break;
658: case BGP_MSG_NOTIFY:
659: peer->notify_out++;
660: /* Double start timer. */
661: peer->v_start *= 2;
662:
663: /* Overflow check. */
664: if (peer->v_start >= (60 * 2))
665: peer->v_start = (60 * 2);
666:
667: /* Flush any existing events */
668: BGP_EVENT_ADD (peer, BGP_Stop);
669: return 0;
670: case BGP_MSG_KEEPALIVE:
671: peer->keepalive_out++;
672: break;
673: case BGP_MSG_ROUTE_REFRESH_NEW:
674: case BGP_MSG_ROUTE_REFRESH_OLD:
675: peer->refresh_out++;
676: break;
677: case BGP_MSG_CAPABILITY:
678: peer->dynamic_cap_out++;
679: break;
680: }
681:
682: /* OK we send packet so delete it. */
683: bgp_packet_delete (peer);
684: }
685: while (++count < BGP_WRITE_PACKET_MAX &&
686: (s = bgp_write_packet (peer)) != NULL);
687:
688: if (bgp_write_proceed (peer))
689: BGP_WRITE_ON (peer->t_write, bgp_write, peer->fd);
690: else
691: sockopt_cork (peer->fd, 0);
692:
693: return 0;
694: }
695:
696: /* This is only for sending NOTIFICATION message to neighbor. */
697: static int
698: bgp_write_notify (struct peer *peer)
699: {
700: int ret, val;
701: u_char type;
702: struct stream *s;
703:
704: /* There should be at least one packet. */
705: s = stream_fifo_head (peer->obuf);
706: if (!s)
707: return 0;
708: assert (stream_get_endp (s) >= BGP_HEADER_SIZE);
709:
710: /* Put socket in blocking mode. */
711: val = fcntl (peer->fd, F_GETFL, 0);
712: fcntl (peer->fd, F_SETFL, val & ~O_NONBLOCK);
713:
714: ret = writen (peer->fd, STREAM_DATA (s), stream_get_endp (s));
715: if (ret <= 0)
716: {
717: BGP_EVENT_ADD (peer, TCP_fatal_error);
718: return 0;
719: }
720:
721: /* Retrieve BGP packet type. */
722: stream_set_getp (s, BGP_MARKER_SIZE + 2);
723: type = stream_getc (s);
724:
725: assert (type == BGP_MSG_NOTIFY);
726:
727: /* Type should be notify. */
728: peer->notify_out++;
729:
730: /* Double start timer. */
731: peer->v_start *= 2;
732:
733: /* Overflow check. */
734: if (peer->v_start >= (60 * 2))
735: peer->v_start = (60 * 2);
736:
737: BGP_EVENT_ADD (peer, BGP_Stop);
738:
739: return 0;
740: }
741:
742: /* Make keepalive packet and send it to the peer. */
743: void
744: bgp_keepalive_send (struct peer *peer)
745: {
746: struct stream *s;
747: int length;
748:
749: s = stream_new (BGP_MAX_PACKET_SIZE);
750:
751: /* Make keepalive packet. */
752: bgp_packet_set_marker (s, BGP_MSG_KEEPALIVE);
753:
754: /* Set packet size. */
755: length = bgp_packet_set_size (s);
756:
757: /* Dump packet if debug option is set. */
758: /* bgp_packet_dump (s); */
759:
760: if (BGP_DEBUG (keepalive, KEEPALIVE))
761: zlog_debug ("%s sending KEEPALIVE", peer->host);
762: if (BGP_DEBUG (normal, NORMAL))
763: zlog_debug ("%s send message type %d, length (incl. header) %d",
764: peer->host, BGP_MSG_KEEPALIVE, length);
765:
766: /* Add packet to the peer. */
767: bgp_packet_add (peer, s);
768:
769: BGP_WRITE_ON (peer->t_write, bgp_write, peer->fd);
770: }
771:
772: /* Make open packet and send it to the peer. */
773: void
774: bgp_open_send (struct peer *peer)
775: {
776: struct stream *s;
777: int length;
778: u_int16_t send_holdtime;
779: as_t local_as;
780:
781: if (CHECK_FLAG (peer->config, PEER_CONFIG_TIMER))
782: send_holdtime = peer->holdtime;
783: else
784: send_holdtime = peer->bgp->default_holdtime;
785:
786: /* local-as Change */
787: if (peer->change_local_as)
788: local_as = peer->change_local_as;
789: else
790: local_as = peer->local_as;
791:
792: s = stream_new (BGP_MAX_PACKET_SIZE);
793:
794: /* Make open packet. */
795: bgp_packet_set_marker (s, BGP_MSG_OPEN);
796:
797: /* Set open packet values. */
798: stream_putc (s, BGP_VERSION_4); /* BGP version */
799: stream_putw (s, (local_as <= BGP_AS_MAX) ? (u_int16_t) local_as
800: : BGP_AS_TRANS);
801: stream_putw (s, send_holdtime); /* Hold Time */
802: stream_put_in_addr (s, &peer->local_id); /* BGP Identifier */
803:
804: /* Set capability code. */
805: bgp_open_capability (s, peer);
806:
807: /* Set BGP packet length. */
808: length = bgp_packet_set_size (s);
809:
810: if (BGP_DEBUG (normal, NORMAL))
811: zlog_debug ("%s sending OPEN, version %d, my as %u, holdtime %d, id %s",
812: peer->host, BGP_VERSION_4, local_as,
813: send_holdtime, inet_ntoa (peer->local_id));
814:
815: if (BGP_DEBUG (normal, NORMAL))
816: zlog_debug ("%s send message type %d, length (incl. header) %d",
817: peer->host, BGP_MSG_OPEN, length);
818:
819: /* Dump packet if debug option is set. */
820: /* bgp_packet_dump (s); */
821:
822: /* Add packet to the peer. */
823: bgp_packet_add (peer, s);
824:
825: BGP_WRITE_ON (peer->t_write, bgp_write, peer->fd);
826: }
827:
828: /* Send BGP notify packet with data potion. */
829: void
830: bgp_notify_send_with_data (struct peer *peer, u_char code, u_char sub_code,
831: u_char *data, size_t datalen)
832: {
833: struct stream *s;
834: int length;
835:
836: /* Allocate new stream. */
837: s = stream_new (BGP_MAX_PACKET_SIZE);
838:
839: /* Make nitify packet. */
840: bgp_packet_set_marker (s, BGP_MSG_NOTIFY);
841:
842: /* Set notify packet values. */
843: stream_putc (s, code); /* BGP notify code */
844: stream_putc (s, sub_code); /* BGP notify sub_code */
845:
846: /* If notify data is present. */
847: if (data)
848: stream_write (s, data, datalen);
849:
850: /* Set BGP packet length. */
851: length = bgp_packet_set_size (s);
852:
853: /* Add packet to the peer. */
854: stream_fifo_clean (peer->obuf);
855: bgp_packet_add (peer, s);
856:
857: /* For debug */
858: {
859: struct bgp_notify bgp_notify;
860: int first = 0;
861: int i;
862: char c[4];
863:
864: bgp_notify.code = code;
865: bgp_notify.subcode = sub_code;
866: bgp_notify.data = NULL;
867: bgp_notify.length = length - BGP_MSG_NOTIFY_MIN_SIZE;
868:
869: if (bgp_notify.length)
870: {
871: bgp_notify.data = XMALLOC (MTYPE_TMP, bgp_notify.length * 3);
872: for (i = 0; i < bgp_notify.length; i++)
873: if (first)
874: {
875: sprintf (c, " %02x", data[i]);
876: strcat (bgp_notify.data, c);
877: }
878: else
879: {
880: first = 1;
881: sprintf (c, "%02x", data[i]);
882: strcpy (bgp_notify.data, c);
883: }
884: }
885: bgp_notify_print (peer, &bgp_notify, "sending");
886: if (bgp_notify.data)
887: XFREE (MTYPE_TMP, bgp_notify.data);
888: }
889:
890: if (BGP_DEBUG (normal, NORMAL))
891: zlog_debug ("%s send message type %d, length (incl. header) %d",
892: peer->host, BGP_MSG_NOTIFY, length);
893:
894: /* peer reset cause */
895: if (sub_code != BGP_NOTIFY_CEASE_CONFIG_CHANGE)
896: {
897: if (sub_code == BGP_NOTIFY_CEASE_ADMIN_RESET)
898: {
899: peer->last_reset = PEER_DOWN_USER_RESET;
900: zlog_info ("Notification sent to neighbor %s: User reset", peer->host);
901: }
902: else if (sub_code == BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN)
903: {
904: peer->last_reset = PEER_DOWN_USER_SHUTDOWN;
905: zlog_info ("Notification sent to neighbor %s: shutdown", peer->host);
906: }
907: else
908: {
909: peer->last_reset = PEER_DOWN_NOTIFY_SEND;
910: zlog_info ("Notification sent to neighbor %s: type %u/%u",
911: peer->host, code, sub_code);
912: }
913: }
914: else
915: zlog_info ("Notification sent to neighbor %s: configuration change",
916: peer->host);
917:
918: /* Call immediately. */
919: BGP_WRITE_OFF (peer->t_write);
920:
921: bgp_write_notify (peer);
922: }
923:
924: /* Send BGP notify packet. */
925: void
926: bgp_notify_send (struct peer *peer, u_char code, u_char sub_code)
927: {
928: bgp_notify_send_with_data (peer, code, sub_code, NULL, 0);
929: }
930:
931: /* Send route refresh message to the peer. */
932: void
933: bgp_route_refresh_send (struct peer *peer, afi_t afi, safi_t safi,
934: u_char orf_type, u_char when_to_refresh, int remove)
935: {
936: struct stream *s;
937: struct stream *packet;
938: int length;
939: struct bgp_filter *filter;
940: int orf_refresh = 0;
941:
942: if (DISABLE_BGP_ANNOUNCE)
943: return;
944:
945: filter = &peer->filter[afi][safi];
946:
947: /* Adjust safi code. */
948: if (safi == SAFI_MPLS_VPN)
949: safi = BGP_SAFI_VPNV4;
950:
951: s = stream_new (BGP_MAX_PACKET_SIZE);
952:
953: /* Make BGP update packet. */
954: if (CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_NEW_RCV))
955: bgp_packet_set_marker (s, BGP_MSG_ROUTE_REFRESH_NEW);
956: else
957: bgp_packet_set_marker (s, BGP_MSG_ROUTE_REFRESH_OLD);
958:
959: /* Encode Route Refresh message. */
960: stream_putw (s, afi);
961: stream_putc (s, 0);
962: stream_putc (s, safi);
963:
964: if (orf_type == ORF_TYPE_PREFIX
965: || orf_type == ORF_TYPE_PREFIX_OLD)
966: if (remove || filter->plist[FILTER_IN].plist)
967: {
968: u_int16_t orf_len;
969: unsigned long orfp;
970:
971: orf_refresh = 1;
972: stream_putc (s, when_to_refresh);
973: stream_putc (s, orf_type);
974: orfp = stream_get_endp (s);
975: stream_putw (s, 0);
976:
977: if (remove)
978: {
979: UNSET_FLAG (peer->af_sflags[afi][safi], PEER_STATUS_ORF_PREFIX_SEND);
980: stream_putc (s, ORF_COMMON_PART_REMOVE_ALL);
981: if (BGP_DEBUG (normal, NORMAL))
982: zlog_debug ("%s sending REFRESH_REQ to remove ORF(%d) (%s) for afi/safi: %d/%d",
983: peer->host, orf_type,
984: (when_to_refresh == REFRESH_DEFER ? "defer" : "immediate"),
985: afi, safi);
986: }
987: else
988: {
989: SET_FLAG (peer->af_sflags[afi][safi], PEER_STATUS_ORF_PREFIX_SEND);
990: prefix_bgp_orf_entry (s, filter->plist[FILTER_IN].plist,
991: ORF_COMMON_PART_ADD, ORF_COMMON_PART_PERMIT,
992: ORF_COMMON_PART_DENY);
993: if (BGP_DEBUG (normal, NORMAL))
994: zlog_debug ("%s sending REFRESH_REQ with pfxlist ORF(%d) (%s) for afi/safi: %d/%d",
995: peer->host, orf_type,
996: (when_to_refresh == REFRESH_DEFER ? "defer" : "immediate"),
997: afi, safi);
998: }
999:
1000: /* Total ORF Entry Len. */
1001: orf_len = stream_get_endp (s) - orfp - 2;
1002: stream_putw_at (s, orfp, orf_len);
1003: }
1004:
1005: /* Set packet size. */
1006: length = bgp_packet_set_size (s);
1007:
1008: if (BGP_DEBUG (normal, NORMAL))
1009: {
1010: if (! orf_refresh)
1011: zlog_debug ("%s sending REFRESH_REQ for afi/safi: %d/%d",
1012: peer->host, afi, safi);
1013: zlog_debug ("%s send message type %d, length (incl. header) %d",
1014: peer->host, CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_NEW_RCV) ?
1015: BGP_MSG_ROUTE_REFRESH_NEW : BGP_MSG_ROUTE_REFRESH_OLD, length);
1016: }
1017:
1018: /* Make real packet. */
1019: packet = stream_dup (s);
1020: stream_free (s);
1021:
1022: /* Add packet to the peer. */
1023: bgp_packet_add (peer, packet);
1024:
1025: BGP_WRITE_ON (peer->t_write, bgp_write, peer->fd);
1026: }
1027:
1028: /* Send capability message to the peer. */
1029: void
1030: bgp_capability_send (struct peer *peer, afi_t afi, safi_t safi,
1031: int capability_code, int action)
1032: {
1033: struct stream *s;
1034: struct stream *packet;
1035: int length;
1036:
1037: /* Adjust safi code. */
1038: if (safi == SAFI_MPLS_VPN)
1039: safi = BGP_SAFI_VPNV4;
1040:
1041: s = stream_new (BGP_MAX_PACKET_SIZE);
1042:
1043: /* Make BGP update packet. */
1044: bgp_packet_set_marker (s, BGP_MSG_CAPABILITY);
1045:
1046: /* Encode MP_EXT capability. */
1047: if (capability_code == CAPABILITY_CODE_MP)
1048: {
1049: stream_putc (s, action);
1050: stream_putc (s, CAPABILITY_CODE_MP);
1051: stream_putc (s, CAPABILITY_CODE_MP_LEN);
1052: stream_putw (s, afi);
1053: stream_putc (s, 0);
1054: stream_putc (s, safi);
1055:
1056: if (BGP_DEBUG (normal, NORMAL))
1057: zlog_debug ("%s sending CAPABILITY has %s MP_EXT CAP for afi/safi: %d/%d",
1058: peer->host, action == CAPABILITY_ACTION_SET ?
1059: "Advertising" : "Removing", afi, safi);
1060: }
1061:
1062: /* Set packet size. */
1063: length = bgp_packet_set_size (s);
1064:
1065: /* Make real packet. */
1066: packet = stream_dup (s);
1067: stream_free (s);
1068:
1069: /* Add packet to the peer. */
1070: bgp_packet_add (peer, packet);
1071:
1072: if (BGP_DEBUG (normal, NORMAL))
1073: zlog_debug ("%s send message type %d, length (incl. header) %d",
1074: peer->host, BGP_MSG_CAPABILITY, length);
1075:
1076: BGP_WRITE_ON (peer->t_write, bgp_write, peer->fd);
1077: }
1078:
1079: /* RFC1771 6.8 Connection collision detection. */
1080: static int
1081: bgp_collision_detect (struct peer *new, struct in_addr remote_id)
1082: {
1083: struct peer *peer;
1084: struct listnode *node, *nnode;
1085: struct bgp *bgp;
1086:
1087: bgp = bgp_get_default ();
1088: if (! bgp)
1089: return 0;
1090:
1091: /* Upon receipt of an OPEN message, the local system must examine
1092: all of its connections that are in the OpenConfirm state. A BGP
1093: speaker may also examine connections in an OpenSent state if it
1094: knows the BGP Identifier of the peer by means outside of the
1095: protocol. If among these connections there is a connection to a
1096: remote BGP speaker whose BGP Identifier equals the one in the
1097: OPEN message, then the local system performs the following
1098: collision resolution procedure: */
1099:
1100: for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
1101: {
1102: /* Under OpenConfirm status, local peer structure already hold
1103: remote router ID. */
1104:
1105: if (peer != new
1106: && (peer->status == OpenConfirm || peer->status == OpenSent)
1107: && sockunion_same (&peer->su, &new->su))
1108: {
1109: /* 1. The BGP Identifier of the local system is compared to
1110: the BGP Identifier of the remote system (as specified in
1111: the OPEN message). */
1112:
1113: if (ntohl (peer->local_id.s_addr) < ntohl (remote_id.s_addr))
1114: {
1115: /* 2. If the value of the local BGP Identifier is less
1116: than the remote one, the local system closes BGP
1117: connection that already exists (the one that is
1118: already in the OpenConfirm state), and accepts BGP
1119: connection initiated by the remote system. */
1120:
1121: if (peer->fd >= 0)
1122: bgp_notify_send (peer, BGP_NOTIFY_CEASE, BGP_NOTIFY_CEASE_COLLISION_RESOLUTION);
1123: return 1;
1124: }
1125: else
1126: {
1127: /* 3. Otherwise, the local system closes newly created
1128: BGP connection (the one associated with the newly
1129: received OPEN message), and continues to use the
1130: existing one (the one that is already in the
1131: OpenConfirm state). */
1132:
1133: if (new->fd >= 0)
1134: bgp_notify_send (new, BGP_NOTIFY_CEASE,
1135: BGP_NOTIFY_CEASE_COLLISION_RESOLUTION);
1136: return -1;
1137: }
1138: }
1139: }
1140: return 0;
1141: }
1142:
1143: static int
1144: bgp_open_receive (struct peer *peer, bgp_size_t size)
1145: {
1146: int ret;
1147: u_char version;
1148: u_char optlen;
1149: u_int16_t holdtime;
1150: u_int16_t send_holdtime;
1151: as_t remote_as;
1152: as_t as4 = 0;
1153: struct peer *realpeer;
1154: struct in_addr remote_id;
1155: int capability;
1156: u_int8_t notify_data_remote_as[2];
1157: u_int8_t notify_data_remote_id[4];
1158:
1159: realpeer = NULL;
1160:
1161: /* Parse open packet. */
1162: version = stream_getc (peer->ibuf);
1163: memcpy (notify_data_remote_as, stream_pnt (peer->ibuf), 2);
1164: remote_as = stream_getw (peer->ibuf);
1165: holdtime = stream_getw (peer->ibuf);
1166: memcpy (notify_data_remote_id, stream_pnt (peer->ibuf), 4);
1167: remote_id.s_addr = stream_get_ipv4 (peer->ibuf);
1168:
1169: /* Receive OPEN message log */
1170: if (BGP_DEBUG (normal, NORMAL))
1171: zlog_debug ("%s rcv OPEN, version %d, remote-as (in open) %u,"
1172: " holdtime %d, id %s",
1173: peer->host, version, remote_as, holdtime,
1174: inet_ntoa (remote_id));
1175:
1176: /* BEGIN to read the capability here, but dont do it yet */
1177: capability = 0;
1178: optlen = stream_getc (peer->ibuf);
1179:
1180: if (optlen != 0)
1181: {
1182: /* We need the as4 capability value *right now* because
1183: * if it is there, we have not got the remote_as yet, and without
1184: * that we do not know which peer is connecting to us now.
1185: */
1186: as4 = peek_for_as4_capability (peer, optlen);
1187: }
1188:
1189: /* Just in case we have a silly peer who sends AS4 capability set to 0 */
1190: if (CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV) && !as4)
1191: {
1192: zlog_err ("%s bad OPEN, got AS4 capability, but AS4 set to 0",
1193: peer->host);
1194: bgp_notify_send (peer, BGP_NOTIFY_OPEN_ERR,
1195: BGP_NOTIFY_OPEN_BAD_PEER_AS);
1196: return -1;
1197: }
1198:
1199: if (remote_as == BGP_AS_TRANS)
1200: {
1201: /* Take the AS4 from the capability. We must have received the
1202: * capability now! Otherwise we have a asn16 peer who uses
1203: * BGP_AS_TRANS, for some unknown reason.
1204: */
1205: if (as4 == BGP_AS_TRANS)
1206: {
1207: zlog_err ("%s [AS4] NEW speaker using AS_TRANS for AS4, not allowed",
1208: peer->host);
1209: bgp_notify_send (peer, BGP_NOTIFY_OPEN_ERR,
1210: BGP_NOTIFY_OPEN_BAD_PEER_AS);
1211: return -1;
1212: }
1213:
1214: if (!as4 && BGP_DEBUG (as4, AS4))
1215: zlog_debug ("%s [AS4] OPEN remote_as is AS_TRANS, but no AS4."
1216: " Odd, but proceeding.", peer->host);
1217: else if (as4 < BGP_AS_MAX && BGP_DEBUG (as4, AS4))
1218: zlog_debug ("%s [AS4] OPEN remote_as is AS_TRANS, but AS4 (%u) fits "
1219: "in 2-bytes, very odd peer.", peer->host, as4);
1220: if (as4)
1221: remote_as = as4;
1222: }
1223: else
1224: {
1225: /* We may have a partner with AS4 who has an asno < BGP_AS_MAX */
1226: /* If we have got the capability, peer->as4cap must match remote_as */
1227: if (CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV)
1228: && as4 != remote_as)
1229: {
1230: /* raise error, log this, close session */
1231: zlog_err ("%s bad OPEN, got AS4 capability, but remote_as %u"
1232: " mismatch with 16bit 'myasn' %u in open",
1233: peer->host, as4, remote_as);
1234: bgp_notify_send (peer, BGP_NOTIFY_OPEN_ERR,
1235: BGP_NOTIFY_OPEN_BAD_PEER_AS);
1236: return -1;
1237: }
1238: }
1239:
1240: /* Lookup peer from Open packet. */
1241: if (CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
1242: {
1243: int as = 0;
1244:
1245: realpeer = peer_lookup_with_open (&peer->su, remote_as, &remote_id, &as);
1246:
1247: if (! realpeer)
1248: {
1249: /* Peer's source IP address is check in bgp_accept(), so this
1250: must be AS number mismatch or remote-id configuration
1251: mismatch. */
1252: if (as)
1253: {
1254: if (BGP_DEBUG (normal, NORMAL))
1255: zlog_debug ("%s bad OPEN, wrong router identifier %s",
1256: peer->host, inet_ntoa (remote_id));
1257: bgp_notify_send_with_data (peer, BGP_NOTIFY_OPEN_ERR,
1258: BGP_NOTIFY_OPEN_BAD_BGP_IDENT,
1259: notify_data_remote_id, 4);
1260: }
1261: else
1262: {
1263: if (BGP_DEBUG (normal, NORMAL))
1264: zlog_debug ("%s bad OPEN, remote AS is %u, expected %u",
1265: peer->host, remote_as, peer->as);
1266: bgp_notify_send_with_data (peer, BGP_NOTIFY_OPEN_ERR,
1267: BGP_NOTIFY_OPEN_BAD_PEER_AS,
1268: notify_data_remote_as, 2);
1269: }
1270: return -1;
1271: }
1272: }
1273:
1274: /* When collision is detected and this peer is closed. Retrun
1275: immidiately. */
1276: ret = bgp_collision_detect (peer, remote_id);
1277: if (ret < 0)
1278: return ret;
1279:
1280: /* Hack part. */
1281: if (CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
1282: {
1283: if (realpeer->status == Established
1284: && CHECK_FLAG (realpeer->sflags, PEER_STATUS_NSF_MODE))
1285: {
1286: realpeer->last_reset = PEER_DOWN_NSF_CLOSE_SESSION;
1287: SET_FLAG (realpeer->sflags, PEER_STATUS_NSF_WAIT);
1288: }
1289: else if (ret == 0 && realpeer->status != Active
1290: && realpeer->status != OpenSent
1291: && realpeer->status != OpenConfirm
1292: && realpeer->status != Connect)
1293: {
1294: /* XXX: This is an awful problem..
1295: *
1296: * According to the RFC we should just let this connection (of the
1297: * accepted 'peer') continue on to Established if the other
1298: * connection (the 'realpeer' one) is in state Connect, and deal
1299: * with the more larval FSM as/when it gets far enough to receive
1300: * an Open. We don't do that though, we instead close the (more
1301: * developed) accepted connection.
1302: *
1303: * This means there's a race, which if hit, can loop:
1304: *
1305: * FSM for A FSM for B
1306: * realpeer accept-peer realpeer accept-peer
1307: *
1308: * Connect Connect
1309: * Active
1310: * OpenSent OpenSent
1311: * <arrive here,
1312: * Notify, delete>
1313: * Idle Active
1314: * OpenSent OpenSent
1315: * <arrive here,
1316: * Notify, delete>
1317: * Idle
1318: * <wait> <wait>
1319: * Connect Connect
1320: *
1321: *
1322: * If both sides are Quagga, they're almost certain to wait for
1323: * the same amount of time of course (which doesn't preclude other
1324: * implementations also waiting for same time). The race is
1325: * exacerbated by high-latency (in bgpd and/or the network).
1326: *
1327: * The reason we do this is because our FSM is tied to our peer
1328: * structure, which carries our configuration information, etc.
1329: * I.e. we can't let the accepted-peer FSM continue on as it is,
1330: * cause it's not associated with any actual peer configuration -
1331: * it's just a dummy.
1332: *
1333: * It's possible we could hack-fix this by just bgp_stop'ing the
1334: * realpeer and continueing on with the 'transfer FSM' below.
1335: * Ideally, we need to seperate FSMs from struct peer.
1336: *
1337: * Setting one side to passive avoids the race, as a workaround.
1338: */
1339: if (BGP_DEBUG (events, EVENTS))
1340: zlog_debug ("%s peer status is %s close connection",
1341: realpeer->host, LOOKUP (bgp_status_msg,
1342: realpeer->status));
1343: bgp_notify_send (peer, BGP_NOTIFY_CEASE,
1344: BGP_NOTIFY_CEASE_CONNECT_REJECT);
1345:
1346: return -1;
1347: }
1348:
1349: if (BGP_DEBUG (events, EVENTS))
1350: zlog_debug ("%s [Event] Transfer accept BGP peer to real (state %s)",
1351: peer->host,
1352: LOOKUP (bgp_status_msg, realpeer->status));
1353:
1354: bgp_stop (realpeer);
1355:
1356: /* Transfer file descriptor. */
1357: realpeer->fd = peer->fd;
1358: peer->fd = -1;
1359:
1360: /* Transfer input buffer. */
1361: stream_free (realpeer->ibuf);
1362: realpeer->ibuf = peer->ibuf;
1363: realpeer->packet_size = peer->packet_size;
1364: peer->ibuf = NULL;
1365:
1366: /* Transfer status. */
1367: realpeer->status = peer->status;
1368: bgp_stop (peer);
1369:
1370: /* peer pointer change. Open packet send to neighbor. */
1371: peer = realpeer;
1372: bgp_open_send (peer);
1373: if (peer->fd < 0)
1374: {
1375: zlog_err ("bgp_open_receive peer's fd is negative value %d",
1376: peer->fd);
1377: return -1;
1378: }
1379: BGP_READ_ON (peer->t_read, bgp_read, peer->fd);
1380: }
1381:
1382: /* remote router-id check. */
1383: if (remote_id.s_addr == 0
1384: || ntohl (remote_id.s_addr) >= 0xe0000000
1385: || ntohl (peer->local_id.s_addr) == ntohl (remote_id.s_addr))
1386: {
1387: if (BGP_DEBUG (normal, NORMAL))
1388: zlog_debug ("%s bad OPEN, wrong router identifier %s",
1389: peer->host, inet_ntoa (remote_id));
1390: bgp_notify_send_with_data (peer,
1391: BGP_NOTIFY_OPEN_ERR,
1392: BGP_NOTIFY_OPEN_BAD_BGP_IDENT,
1393: notify_data_remote_id, 4);
1394: return -1;
1395: }
1396:
1397: /* Set remote router-id */
1398: peer->remote_id = remote_id;
1399:
1400: /* Peer BGP version check. */
1401: if (version != BGP_VERSION_4)
1402: {
1403: u_int8_t maxver = BGP_VERSION_4;
1404: if (BGP_DEBUG (normal, NORMAL))
1405: zlog_debug ("%s bad protocol version, remote requested %d, local request %d",
1406: peer->host, version, BGP_VERSION_4);
1407: bgp_notify_send_with_data (peer,
1408: BGP_NOTIFY_OPEN_ERR,
1409: BGP_NOTIFY_OPEN_UNSUP_VERSION,
1410: &maxver, 1);
1411: return -1;
1412: }
1413:
1414: /* Check neighbor as number. */
1415: if (remote_as != peer->as)
1416: {
1417: if (BGP_DEBUG (normal, NORMAL))
1418: zlog_debug ("%s bad OPEN, remote AS is %u, expected %u",
1419: peer->host, remote_as, peer->as);
1420: bgp_notify_send_with_data (peer,
1421: BGP_NOTIFY_OPEN_ERR,
1422: BGP_NOTIFY_OPEN_BAD_PEER_AS,
1423: notify_data_remote_as, 2);
1424: return -1;
1425: }
1426:
1427: /* From the rfc: Upon receipt of an OPEN message, a BGP speaker MUST
1428: calculate the value of the Hold Timer by using the smaller of its
1429: configured Hold Time and the Hold Time received in the OPEN message.
1430: The Hold Time MUST be either zero or at least three seconds. An
1431: implementation may reject connections on the basis of the Hold Time. */
1432:
1433: if (holdtime < 3 && holdtime != 0)
1434: {
1435: bgp_notify_send (peer,
1436: BGP_NOTIFY_OPEN_ERR,
1437: BGP_NOTIFY_OPEN_UNACEP_HOLDTIME);
1438: return -1;
1439: }
1440:
1441: /* From the rfc: A reasonable maximum time between KEEPALIVE messages
1442: would be one third of the Hold Time interval. KEEPALIVE messages
1443: MUST NOT be sent more frequently than one per second. An
1444: implementation MAY adjust the rate at which it sends KEEPALIVE
1445: messages as a function of the Hold Time interval. */
1446:
1447: if (CHECK_FLAG (peer->config, PEER_CONFIG_TIMER))
1448: send_holdtime = peer->holdtime;
1449: else
1450: send_holdtime = peer->bgp->default_holdtime;
1451:
1452: if (holdtime < send_holdtime)
1453: peer->v_holdtime = holdtime;
1454: else
1455: peer->v_holdtime = send_holdtime;
1456:
1457: peer->v_keepalive = peer->v_holdtime / 3;
1458:
1459: /* Open option part parse. */
1460: if (optlen != 0)
1461: {
1462: ret = bgp_open_option_parse (peer, optlen, &capability);
1463: if (ret < 0)
1464: return ret;
1465: }
1466: else
1467: {
1468: if (BGP_DEBUG (normal, NORMAL))
1469: zlog_debug ("%s rcvd OPEN w/ OPTION parameter len: 0",
1470: peer->host);
1471: }
1472:
1473: /* Override capability. */
1474: if (! capability || CHECK_FLAG (peer->flags, PEER_FLAG_OVERRIDE_CAPABILITY))
1475: {
1476: peer->afc_nego[AFI_IP][SAFI_UNICAST] = peer->afc[AFI_IP][SAFI_UNICAST];
1477: peer->afc_nego[AFI_IP][SAFI_MULTICAST] = peer->afc[AFI_IP][SAFI_MULTICAST];
1478: peer->afc_nego[AFI_IP6][SAFI_UNICAST] = peer->afc[AFI_IP6][SAFI_UNICAST];
1479: peer->afc_nego[AFI_IP6][SAFI_MULTICAST] = peer->afc[AFI_IP6][SAFI_MULTICAST];
1480: }
1481:
1482: /* Get sockname. */
1483: bgp_getsockname (peer);
1484:
1485: BGP_EVENT_ADD (peer, Receive_OPEN_message);
1486:
1487: peer->packet_size = 0;
1488: if (peer->ibuf)
1489: stream_reset (peer->ibuf);
1490:
1491: return 0;
1492: }
1493:
1494: /* Parse BGP Update packet and make attribute object. */
1495: static int
1496: bgp_update_receive (struct peer *peer, bgp_size_t size)
1497: {
1498: int ret;
1499: u_char *end;
1500: struct stream *s;
1501: struct attr attr;
1502: bgp_size_t attribute_len;
1503: bgp_size_t update_len;
1504: bgp_size_t withdraw_len;
1505: struct bgp_nlri update;
1506: struct bgp_nlri withdraw;
1507: struct bgp_nlri mp_update;
1508: struct bgp_nlri mp_withdraw;
1509: char attrstr[BUFSIZ] = "";
1510:
1511: /* Status must be Established. */
1512: if (peer->status != Established)
1513: {
1514: zlog_err ("%s [FSM] Update packet received under status %s",
1515: peer->host, LOOKUP (bgp_status_msg, peer->status));
1516: bgp_notify_send (peer, BGP_NOTIFY_FSM_ERR, 0);
1517: return -1;
1518: }
1519:
1520: /* Set initial values. */
1521: memset (&attr, 0, sizeof (struct attr));
1522: memset (&update, 0, sizeof (struct bgp_nlri));
1523: memset (&withdraw, 0, sizeof (struct bgp_nlri));
1524: memset (&mp_update, 0, sizeof (struct bgp_nlri));
1525: memset (&mp_withdraw, 0, sizeof (struct bgp_nlri));
1526:
1527: s = peer->ibuf;
1528: end = stream_pnt (s) + size;
1529:
1530: /* RFC1771 6.3 If the Unfeasible Routes Length or Total Attribute
1531: Length is too large (i.e., if Unfeasible Routes Length + Total
1532: Attribute Length + 23 exceeds the message Length), then the Error
1533: Subcode is set to Malformed Attribute List. */
1534: if (stream_pnt (s) + 2 > end)
1535: {
1536: zlog_err ("%s [Error] Update packet error"
1537: " (packet length is short for unfeasible length)",
1538: peer->host);
1539: bgp_notify_send (peer, BGP_NOTIFY_UPDATE_ERR,
1540: BGP_NOTIFY_UPDATE_MAL_ATTR);
1541: return -1;
1542: }
1543:
1544: /* Unfeasible Route Length. */
1545: withdraw_len = stream_getw (s);
1546:
1547: /* Unfeasible Route Length check. */
1548: if (stream_pnt (s) + withdraw_len > end)
1549: {
1550: zlog_err ("%s [Error] Update packet error"
1551: " (packet unfeasible length overflow %d)",
1552: peer->host, withdraw_len);
1553: bgp_notify_send (peer, BGP_NOTIFY_UPDATE_ERR,
1554: BGP_NOTIFY_UPDATE_MAL_ATTR);
1555: return -1;
1556: }
1557:
1558: /* Unfeasible Route packet format check. */
1559: if (withdraw_len > 0)
1560: {
1561: ret = bgp_nlri_sanity_check (peer, AFI_IP, stream_pnt (s), withdraw_len);
1562: if (ret < 0)
1563: return -1;
1564:
1565: if (BGP_DEBUG (packet, PACKET_RECV))
1566: zlog_debug ("%s [Update:RECV] Unfeasible NLRI received", peer->host);
1567:
1568: withdraw.afi = AFI_IP;
1569: withdraw.safi = SAFI_UNICAST;
1570: withdraw.nlri = stream_pnt (s);
1571: withdraw.length = withdraw_len;
1572: stream_forward_getp (s, withdraw_len);
1573: }
1574:
1575: /* Attribute total length check. */
1576: if (stream_pnt (s) + 2 > end)
1577: {
1578: zlog_warn ("%s [Error] Packet Error"
1579: " (update packet is short for attribute length)",
1580: peer->host);
1581: bgp_notify_send (peer, BGP_NOTIFY_UPDATE_ERR,
1582: BGP_NOTIFY_UPDATE_MAL_ATTR);
1583: return -1;
1584: }
1585:
1586: /* Fetch attribute total length. */
1587: attribute_len = stream_getw (s);
1588:
1589: /* Attribute length check. */
1590: if (stream_pnt (s) + attribute_len > end)
1591: {
1592: zlog_warn ("%s [Error] Packet Error"
1593: " (update packet attribute length overflow %d)",
1594: peer->host, attribute_len);
1595: bgp_notify_send (peer, BGP_NOTIFY_UPDATE_ERR,
1596: BGP_NOTIFY_UPDATE_MAL_ATTR);
1597: return -1;
1598: }
1599:
1600: /* Certain attribute parsing errors should not be considered bad enough
1601: * to reset the session for, most particularly any partial/optional
1602: * attributes that have 'tunneled' over speakers that don't understand
1603: * them. Instead we withdraw only the prefix concerned.
1604: *
1605: * Complicates the flow a little though..
1606: */
1607: bgp_attr_parse_ret_t attr_parse_ret = BGP_ATTR_PARSE_PROCEED;
1608: /* This define morphs the update case into a withdraw when lower levels
1609: * have signalled an error condition where this is best.
1610: */
1611: #define NLRI_ATTR_ARG (attr_parse_ret != BGP_ATTR_PARSE_WITHDRAW ? &attr : NULL)
1612:
1613: /* Parse attribute when it exists. */
1614: if (attribute_len)
1615: {
1616: attr_parse_ret = bgp_attr_parse (peer, &attr, attribute_len,
1617: &mp_update, &mp_withdraw);
1618: if (attr_parse_ret == BGP_ATTR_PARSE_ERROR)
1619: return -1;
1620: }
1621:
1622: /* Logging the attribute. */
1623: if (attr_parse_ret == BGP_ATTR_PARSE_WITHDRAW
1624: || BGP_DEBUG (update, UPDATE_IN))
1625: {
1626: ret= bgp_dump_attr (peer, &attr, attrstr, BUFSIZ);
1627: int lvl = (attr_parse_ret == BGP_ATTR_PARSE_WITHDRAW)
1628: ? LOG_ERR : LOG_DEBUG;
1629:
1630: if (attr_parse_ret == BGP_ATTR_PARSE_WITHDRAW)
1631: zlog (peer->log, LOG_ERR,
1632: "%s rcvd UPDATE with errors in attr(s)!! Withdrawing route.",
1633: peer->host);
1634:
1635: if (ret)
1636: zlog (peer->log, lvl, "%s rcvd UPDATE w/ attr: %s",
1637: peer->host, attrstr);
1638: }
1639:
1640: /* Network Layer Reachability Information. */
1641: update_len = end - stream_pnt (s);
1642:
1643: if (update_len)
1644: {
1645: /* Check NLRI packet format and prefix length. */
1646: ret = bgp_nlri_sanity_check (peer, AFI_IP, stream_pnt (s), update_len);
1647: if (ret < 0)
1648: {
1649: bgp_attr_unintern_sub (&attr);
1650: if (attr.extra)
1651: bgp_attr_extra_free (&attr);
1652: return -1;
1653: }
1654:
1655: /* Set NLRI portion to structure. */
1656: update.afi = AFI_IP;
1657: update.safi = SAFI_UNICAST;
1658: update.nlri = stream_pnt (s);
1659: update.length = update_len;
1660: stream_forward_getp (s, update_len);
1661: }
1662:
1663: /* NLRI is processed only when the peer is configured specific
1664: Address Family and Subsequent Address Family. */
1665: if (peer->afc[AFI_IP][SAFI_UNICAST])
1666: {
1667: if (withdraw.length)
1668: bgp_nlri_parse (peer, NULL, &withdraw);
1669:
1670: if (update.length)
1671: {
1672: /* We check well-known attribute only for IPv4 unicast
1673: update. */
1674: ret = bgp_attr_check (peer, &attr);
1675: if (ret < 0)
1676: {
1677: bgp_attr_unintern_sub (&attr);
1678: if (attr.extra)
1679: bgp_attr_extra_free (&attr);
1680: return -1;
1681: }
1682:
1683: bgp_nlri_parse (peer, NLRI_ATTR_ARG, &update);
1684: }
1685:
1686: if (mp_update.length
1687: && mp_update.afi == AFI_IP
1688: && mp_update.safi == SAFI_UNICAST)
1689: bgp_nlri_parse (peer, NLRI_ATTR_ARG, &mp_update);
1690:
1691: if (mp_withdraw.length
1692: && mp_withdraw.afi == AFI_IP
1693: && mp_withdraw.safi == SAFI_UNICAST)
1694: bgp_nlri_parse (peer, NULL, &mp_withdraw);
1695:
1696: if (! attribute_len && ! withdraw_len)
1697: {
1698: /* End-of-RIB received */
1699: SET_FLAG (peer->af_sflags[AFI_IP][SAFI_UNICAST],
1700: PEER_STATUS_EOR_RECEIVED);
1701:
1702: /* NSF delete stale route */
1703: if (peer->nsf[AFI_IP][SAFI_UNICAST])
1704: bgp_clear_stale_route (peer, AFI_IP, SAFI_UNICAST);
1705:
1706: if (BGP_DEBUG (normal, NORMAL))
1707: zlog (peer->log, LOG_DEBUG, "rcvd End-of-RIB for IPv4 Unicast from %s",
1708: peer->host);
1709: }
1710: }
1711: if (peer->afc[AFI_IP][SAFI_MULTICAST])
1712: {
1713: if (mp_update.length
1714: && mp_update.afi == AFI_IP
1715: && mp_update.safi == SAFI_MULTICAST)
1716: bgp_nlri_parse (peer, NLRI_ATTR_ARG, &mp_update);
1717:
1718: if (mp_withdraw.length
1719: && mp_withdraw.afi == AFI_IP
1720: && mp_withdraw.safi == SAFI_MULTICAST)
1721: bgp_nlri_parse (peer, NULL, &mp_withdraw);
1722:
1723: if (! withdraw_len
1724: && mp_withdraw.afi == AFI_IP
1725: && mp_withdraw.safi == SAFI_MULTICAST
1726: && mp_withdraw.length == 0)
1727: {
1728: /* End-of-RIB received */
1729: SET_FLAG (peer->af_sflags[AFI_IP][SAFI_MULTICAST],
1730: PEER_STATUS_EOR_RECEIVED);
1731:
1732: /* NSF delete stale route */
1733: if (peer->nsf[AFI_IP][SAFI_MULTICAST])
1734: bgp_clear_stale_route (peer, AFI_IP, SAFI_MULTICAST);
1735:
1736: if (BGP_DEBUG (normal, NORMAL))
1737: zlog (peer->log, LOG_DEBUG, "rcvd End-of-RIB for IPv4 Multicast from %s",
1738: peer->host);
1739: }
1740: }
1741: if (peer->afc[AFI_IP6][SAFI_UNICAST])
1742: {
1743: if (mp_update.length
1744: && mp_update.afi == AFI_IP6
1745: && mp_update.safi == SAFI_UNICAST)
1746: bgp_nlri_parse (peer, NLRI_ATTR_ARG, &mp_update);
1747:
1748: if (mp_withdraw.length
1749: && mp_withdraw.afi == AFI_IP6
1750: && mp_withdraw.safi == SAFI_UNICAST)
1751: bgp_nlri_parse (peer, NULL, &mp_withdraw);
1752:
1753: if (! withdraw_len
1754: && mp_withdraw.afi == AFI_IP6
1755: && mp_withdraw.safi == SAFI_UNICAST
1756: && mp_withdraw.length == 0)
1757: {
1758: /* End-of-RIB received */
1759: SET_FLAG (peer->af_sflags[AFI_IP6][SAFI_UNICAST], PEER_STATUS_EOR_RECEIVED);
1760:
1761: /* NSF delete stale route */
1762: if (peer->nsf[AFI_IP6][SAFI_UNICAST])
1763: bgp_clear_stale_route (peer, AFI_IP6, SAFI_UNICAST);
1764:
1765: if (BGP_DEBUG (normal, NORMAL))
1766: zlog (peer->log, LOG_DEBUG, "rcvd End-of-RIB for IPv6 Unicast from %s",
1767: peer->host);
1768: }
1769: }
1770: if (peer->afc[AFI_IP6][SAFI_MULTICAST])
1771: {
1772: if (mp_update.length
1773: && mp_update.afi == AFI_IP6
1774: && mp_update.safi == SAFI_MULTICAST)
1775: bgp_nlri_parse (peer, NLRI_ATTR_ARG, &mp_update);
1776:
1777: if (mp_withdraw.length
1778: && mp_withdraw.afi == AFI_IP6
1779: && mp_withdraw.safi == SAFI_MULTICAST)
1780: bgp_nlri_parse (peer, NULL, &mp_withdraw);
1781:
1782: if (! withdraw_len
1783: && mp_withdraw.afi == AFI_IP6
1784: && mp_withdraw.safi == SAFI_MULTICAST
1785: && mp_withdraw.length == 0)
1786: {
1787: /* End-of-RIB received */
1788:
1789: /* NSF delete stale route */
1790: if (peer->nsf[AFI_IP6][SAFI_MULTICAST])
1791: bgp_clear_stale_route (peer, AFI_IP6, SAFI_MULTICAST);
1792:
1793: if (BGP_DEBUG (update, UPDATE_IN))
1794: zlog (peer->log, LOG_DEBUG, "rcvd End-of-RIB for IPv6 Multicast from %s",
1795: peer->host);
1796: }
1797: }
1798: if (peer->afc[AFI_IP][SAFI_MPLS_VPN])
1799: {
1800: if (mp_update.length
1801: && mp_update.afi == AFI_IP
1802: && mp_update.safi == BGP_SAFI_VPNV4)
1803: bgp_nlri_parse_vpnv4 (peer, NLRI_ATTR_ARG, &mp_update);
1804:
1805: if (mp_withdraw.length
1806: && mp_withdraw.afi == AFI_IP
1807: && mp_withdraw.safi == BGP_SAFI_VPNV4)
1808: bgp_nlri_parse_vpnv4 (peer, NULL, &mp_withdraw);
1809:
1810: if (! withdraw_len
1811: && mp_withdraw.afi == AFI_IP
1812: && mp_withdraw.safi == BGP_SAFI_VPNV4
1813: && mp_withdraw.length == 0)
1814: {
1815: /* End-of-RIB received */
1816:
1817: if (BGP_DEBUG (update, UPDATE_IN))
1818: zlog (peer->log, LOG_DEBUG, "rcvd End-of-RIB for VPNv4 Unicast from %s",
1819: peer->host);
1820: }
1821: }
1822:
1823: /* Everything is done. We unintern temporary structures which
1824: interned in bgp_attr_parse(). */
1825: bgp_attr_unintern_sub (&attr);
1826: if (attr.extra)
1827: bgp_attr_extra_free (&attr);
1828:
1829: /* If peering is stopped due to some reason, do not generate BGP
1830: event. */
1831: if (peer->status != Established)
1832: return 0;
1833:
1834: /* Increment packet counter. */
1835: peer->update_in++;
1836: peer->update_time = bgp_clock ();
1837:
1838: /* Generate BGP event. */
1839: BGP_EVENT_ADD (peer, Receive_UPDATE_message);
1840:
1841: return 0;
1842: }
1843:
1844: /* Notify message treatment function. */
1845: static void
1846: bgp_notify_receive (struct peer *peer, bgp_size_t size)
1847: {
1848: struct bgp_notify bgp_notify;
1849:
1850: if (peer->notify.data)
1851: {
1852: XFREE (MTYPE_TMP, peer->notify.data);
1853: peer->notify.data = NULL;
1854: peer->notify.length = 0;
1855: }
1856:
1857: bgp_notify.code = stream_getc (peer->ibuf);
1858: bgp_notify.subcode = stream_getc (peer->ibuf);
1859: bgp_notify.length = size - 2;
1860: bgp_notify.data = NULL;
1861:
1862: /* Preserv notify code and sub code. */
1863: peer->notify.code = bgp_notify.code;
1864: peer->notify.subcode = bgp_notify.subcode;
1865: /* For further diagnostic record returned Data. */
1866: if (bgp_notify.length)
1867: {
1868: peer->notify.length = size - 2;
1869: peer->notify.data = XMALLOC (MTYPE_TMP, size - 2);
1870: memcpy (peer->notify.data, stream_pnt (peer->ibuf), size - 2);
1871: }
1872:
1873: /* For debug */
1874: {
1875: int i;
1876: int first = 0;
1877: char c[4];
1878:
1879: if (bgp_notify.length)
1880: {
1881: bgp_notify.data = XMALLOC (MTYPE_TMP, bgp_notify.length * 3);
1882: for (i = 0; i < bgp_notify.length; i++)
1883: if (first)
1884: {
1885: sprintf (c, " %02x", stream_getc (peer->ibuf));
1886: strcat (bgp_notify.data, c);
1887: }
1888: else
1889: {
1890: first = 1;
1891: sprintf (c, "%02x", stream_getc (peer->ibuf));
1892: strcpy (bgp_notify.data, c);
1893: }
1894: }
1895:
1896: bgp_notify_print(peer, &bgp_notify, "received");
1897: if (bgp_notify.data)
1898: XFREE (MTYPE_TMP, bgp_notify.data);
1899: }
1900:
1901: /* peer count update */
1902: peer->notify_in++;
1903:
1904: if (peer->status == Established)
1905: peer->last_reset = PEER_DOWN_NOTIFY_RECEIVED;
1906:
1907: /* We have to check for Notify with Unsupported Optional Parameter.
1908: in that case we fallback to open without the capability option.
1909: But this done in bgp_stop. We just mark it here to avoid changing
1910: the fsm tables. */
1911: if (bgp_notify.code == BGP_NOTIFY_OPEN_ERR &&
1912: bgp_notify.subcode == BGP_NOTIFY_OPEN_UNSUP_PARAM )
1913: UNSET_FLAG (peer->sflags, PEER_STATUS_CAPABILITY_OPEN);
1914:
1915: BGP_EVENT_ADD (peer, Receive_NOTIFICATION_message);
1916: }
1917:
1918: /* Keepalive treatment function -- get keepalive send keepalive */
1919: static void
1920: bgp_keepalive_receive (struct peer *peer, bgp_size_t size)
1921: {
1922: if (BGP_DEBUG (keepalive, KEEPALIVE))
1923: zlog_debug ("%s KEEPALIVE rcvd", peer->host);
1924:
1925: BGP_EVENT_ADD (peer, Receive_KEEPALIVE_message);
1926: }
1927:
1928: /* Route refresh message is received. */
1929: static void
1930: bgp_route_refresh_receive (struct peer *peer, bgp_size_t size)
1931: {
1932: afi_t afi;
1933: safi_t safi;
1934: u_char reserved;
1935: struct stream *s;
1936:
1937: /* If peer does not have the capability, send notification. */
1938: if (! CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_ADV))
1939: {
1940: plog_err (peer->log, "%s [Error] BGP route refresh is not enabled",
1941: peer->host);
1942: bgp_notify_send (peer,
1943: BGP_NOTIFY_HEADER_ERR,
1944: BGP_NOTIFY_HEADER_BAD_MESTYPE);
1945: return;
1946: }
1947:
1948: /* Status must be Established. */
1949: if (peer->status != Established)
1950: {
1951: plog_err (peer->log,
1952: "%s [Error] Route refresh packet received under status %s",
1953: peer->host, LOOKUP (bgp_status_msg, peer->status));
1954: bgp_notify_send (peer, BGP_NOTIFY_FSM_ERR, 0);
1955: return;
1956: }
1957:
1958: s = peer->ibuf;
1959:
1960: /* Parse packet. */
1961: afi = stream_getw (s);
1962: reserved = stream_getc (s);
1963: safi = stream_getc (s);
1964:
1965: if (BGP_DEBUG (normal, NORMAL))
1966: zlog_debug ("%s rcvd REFRESH_REQ for afi/safi: %d/%d",
1967: peer->host, afi, safi);
1968:
1969: /* Check AFI and SAFI. */
1970: if ((afi != AFI_IP && afi != AFI_IP6)
1971: || (safi != SAFI_UNICAST && safi != SAFI_MULTICAST
1972: && safi != BGP_SAFI_VPNV4))
1973: {
1974: if (BGP_DEBUG (normal, NORMAL))
1975: {
1976: zlog_debug ("%s REFRESH_REQ for unrecognized afi/safi: %d/%d - ignored",
1977: peer->host, afi, safi);
1978: }
1979: return;
1980: }
1981:
1982: /* Adjust safi code. */
1983: if (safi == BGP_SAFI_VPNV4)
1984: safi = SAFI_MPLS_VPN;
1985:
1986: if (size != BGP_MSG_ROUTE_REFRESH_MIN_SIZE - BGP_HEADER_SIZE)
1987: {
1988: u_char *end;
1989: u_char when_to_refresh;
1990: u_char orf_type;
1991: u_int16_t orf_len;
1992:
1993: if (size - (BGP_MSG_ROUTE_REFRESH_MIN_SIZE - BGP_HEADER_SIZE) < 5)
1994: {
1995: zlog_info ("%s ORF route refresh length error", peer->host);
1996: bgp_notify_send (peer, BGP_NOTIFY_CEASE, 0);
1997: return;
1998: }
1999:
2000: when_to_refresh = stream_getc (s);
2001: end = stream_pnt (s) + (size - 5);
2002:
2003: while ((stream_pnt (s) + 2) < end)
2004: {
2005: orf_type = stream_getc (s);
2006: orf_len = stream_getw (s);
2007:
2008: /* orf_len in bounds? */
2009: if ((stream_pnt (s) + orf_len) > end)
2010: break; /* XXX: Notify instead?? */
2011: if (orf_type == ORF_TYPE_PREFIX
2012: || orf_type == ORF_TYPE_PREFIX_OLD)
2013: {
2014: u_char *p_pnt = stream_pnt (s);
2015: u_char *p_end = stream_pnt (s) + orf_len;
2016: struct orf_prefix orfp;
2017: u_char common = 0;
2018: u_int32_t seq;
2019: int psize;
2020: char name[BUFSIZ];
2021: char buf[BUFSIZ];
2022: int ret;
2023:
2024: if (BGP_DEBUG (normal, NORMAL))
2025: {
2026: zlog_debug ("%s rcvd Prefixlist ORF(%d) length %d",
2027: peer->host, orf_type, orf_len);
2028: }
2029:
2030: /* we're going to read at least 1 byte of common ORF header,
2031: * and 7 bytes of ORF Address-filter entry from the stream
2032: */
2033: if (orf_len < 7)
2034: break;
2035:
2036: /* ORF prefix-list name */
2037: sprintf (name, "%s.%d.%d", peer->host, afi, safi);
2038:
2039: while (p_pnt < p_end)
2040: {
2041: /* If the ORF entry is malformed, want to read as much of it
2042: * as possible without going beyond the bounds of the entry,
2043: * to maximise debug information.
2044: */
2045: int ok;
2046: memset (&orfp, 0, sizeof (struct orf_prefix));
2047: common = *p_pnt++;
2048: /* after ++: p_pnt <= p_end */
2049: if (common & ORF_COMMON_PART_REMOVE_ALL)
2050: {
2051: if (BGP_DEBUG (normal, NORMAL))
2052: zlog_debug ("%s rcvd Remove-All pfxlist ORF request", peer->host);
2053: prefix_bgp_orf_remove_all (name);
2054: break;
2055: }
2056: ok = ((p_end - p_pnt) >= sizeof(u_int32_t)) ;
2057: if (!ok)
2058: {
2059: memcpy (&seq, p_pnt, sizeof (u_int32_t));
2060: p_pnt += sizeof (u_int32_t);
2061: orfp.seq = ntohl (seq);
2062: }
2063: else
2064: p_pnt = p_end ;
2065:
2066: if ((ok = (p_pnt < p_end)))
2067: orfp.ge = *p_pnt++ ; /* value checked in prefix_bgp_orf_set() */
2068: if ((ok = (p_pnt < p_end)))
2069: orfp.le = *p_pnt++ ; /* value checked in prefix_bgp_orf_set() */
2070: if ((ok = (p_pnt < p_end)))
2071: orfp.p.prefixlen = *p_pnt++ ;
2072: orfp.p.family = afi2family (afi); /* afi checked already */
2073:
2074: psize = PSIZE (orfp.p.prefixlen); /* 0 if not ok */
2075: if (psize > prefix_blen(&orfp.p)) /* valid for family ? */
2076: {
2077: ok = 0 ;
2078: psize = prefix_blen(&orfp.p) ;
2079: }
2080: if (psize > (p_end - p_pnt)) /* valid for packet ? */
2081: {
2082: ok = 0 ;
2083: psize = p_end - p_pnt ;
2084: }
2085:
2086: if (psize > 0)
2087: memcpy (&orfp.p.u.prefix, p_pnt, psize);
2088: p_pnt += psize;
2089:
2090: if (BGP_DEBUG (normal, NORMAL))
2091: zlog_debug ("%s rcvd %s %s seq %u %s/%d ge %d le %d%s",
2092: peer->host,
2093: (common & ORF_COMMON_PART_REMOVE ? "Remove" : "Add"),
2094: (common & ORF_COMMON_PART_DENY ? "deny" : "permit"),
2095: orfp.seq,
2096: inet_ntop (orfp.p.family, &orfp.p.u.prefix, buf, BUFSIZ),
2097: orfp.p.prefixlen, orfp.ge, orfp.le,
2098: ok ? "" : " MALFORMED");
2099:
2100: if (ok)
2101: ret = prefix_bgp_orf_set (name, afi, &orfp,
2102: (common & ORF_COMMON_PART_DENY ? 0 : 1 ),
2103: (common & ORF_COMMON_PART_REMOVE ? 0 : 1));
2104:
2105: if (!ok || (ret != CMD_SUCCESS))
2106: {
2107: if (BGP_DEBUG (normal, NORMAL))
2108: zlog_debug ("%s Received misformatted prefixlist ORF."
2109: " Remove All pfxlist", peer->host);
2110: prefix_bgp_orf_remove_all (name);
2111: break;
2112: }
2113: }
2114: peer->orf_plist[afi][safi] =
2115: prefix_list_lookup (AFI_ORF_PREFIX, name);
2116: }
2117: stream_forward_getp (s, orf_len);
2118: }
2119: if (BGP_DEBUG (normal, NORMAL))
2120: zlog_debug ("%s rcvd Refresh %s ORF request", peer->host,
2121: when_to_refresh == REFRESH_DEFER ? "Defer" : "Immediate");
2122: if (when_to_refresh == REFRESH_DEFER)
2123: return;
2124: }
2125:
2126: /* First update is deferred until ORF or ROUTE-REFRESH is received */
2127: if (CHECK_FLAG (peer->af_sflags[afi][safi], PEER_STATUS_ORF_WAIT_REFRESH))
2128: UNSET_FLAG (peer->af_sflags[afi][safi], PEER_STATUS_ORF_WAIT_REFRESH);
2129:
2130: /* Perform route refreshment to the peer */
2131: bgp_announce_route (peer, afi, safi);
2132: }
2133:
2134: static int
2135: bgp_capability_msg_parse (struct peer *peer, u_char *pnt, bgp_size_t length)
2136: {
2137: u_char *end;
2138: struct capability_mp_data mpc;
2139: struct capability_header *hdr;
2140: u_char action;
2141: struct bgp *bgp;
2142: afi_t afi;
2143: safi_t safi;
2144:
2145: bgp = peer->bgp;
2146: end = pnt + length;
2147:
2148: while (pnt < end)
2149: {
2150: /* We need at least action, capability code and capability length. */
2151: if (pnt + 3 > end)
2152: {
2153: zlog_info ("%s Capability length error", peer->host);
2154: bgp_notify_send (peer, BGP_NOTIFY_CEASE, 0);
2155: return -1;
2156: }
2157: action = *pnt;
2158: hdr = (struct capability_header *)(pnt + 1);
2159:
2160: /* Action value check. */
2161: if (action != CAPABILITY_ACTION_SET
2162: && action != CAPABILITY_ACTION_UNSET)
2163: {
2164: zlog_info ("%s Capability Action Value error %d",
2165: peer->host, action);
2166: bgp_notify_send (peer, BGP_NOTIFY_CEASE, 0);
2167: return -1;
2168: }
2169:
2170: if (BGP_DEBUG (normal, NORMAL))
2171: zlog_debug ("%s CAPABILITY has action: %d, code: %u, length %u",
2172: peer->host, action, hdr->code, hdr->length);
2173:
2174: /* Capability length check. */
2175: if ((pnt + hdr->length + 3) > end)
2176: {
2177: zlog_info ("%s Capability length error", peer->host);
2178: bgp_notify_send (peer, BGP_NOTIFY_CEASE, 0);
2179: return -1;
2180: }
2181:
2182: /* Fetch structure to the byte stream. */
2183: memcpy (&mpc, pnt + 3, sizeof (struct capability_mp_data));
2184:
2185: /* We know MP Capability Code. */
2186: if (hdr->code == CAPABILITY_CODE_MP)
2187: {
2188: afi = ntohs (mpc.afi);
2189: safi = mpc.safi;
2190:
2191: /* Ignore capability when override-capability is set. */
2192: if (CHECK_FLAG (peer->flags, PEER_FLAG_OVERRIDE_CAPABILITY))
2193: continue;
2194:
2195: if (!bgp_afi_safi_valid_indices (afi, &safi))
2196: {
2197: if (BGP_DEBUG (normal, NORMAL))
2198: zlog_debug ("%s Dynamic Capability MP_EXT afi/safi invalid "
2199: "(%u/%u)", peer->host, afi, safi);
2200: continue;
2201: }
2202:
2203: /* Address family check. */
2204: if (BGP_DEBUG (normal, NORMAL))
2205: zlog_debug ("%s CAPABILITY has %s MP_EXT CAP for afi/safi: %u/%u",
2206: peer->host,
2207: action == CAPABILITY_ACTION_SET
2208: ? "Advertising" : "Removing",
2209: ntohs(mpc.afi) , mpc.safi);
2210:
2211: if (action == CAPABILITY_ACTION_SET)
2212: {
2213: peer->afc_recv[afi][safi] = 1;
2214: if (peer->afc[afi][safi])
2215: {
2216: peer->afc_nego[afi][safi] = 1;
2217: bgp_announce_route (peer, afi, safi);
2218: }
2219: }
2220: else
2221: {
2222: peer->afc_recv[afi][safi] = 0;
2223: peer->afc_nego[afi][safi] = 0;
2224:
2225: if (peer_active_nego (peer))
2226: bgp_clear_route (peer, afi, safi, BGP_CLEAR_ROUTE_NORMAL);
2227: else
2228: BGP_EVENT_ADD (peer, BGP_Stop);
2229: }
2230: }
2231: else
2232: {
2233: zlog_warn ("%s unrecognized capability code: %d - ignored",
2234: peer->host, hdr->code);
2235: }
2236: pnt += hdr->length + 3;
2237: }
2238: return 0;
2239: }
2240:
2241: /* Dynamic Capability is received.
2242: *
2243: * This is exported for unit-test purposes
2244: */
2245: int
2246: bgp_capability_receive (struct peer *peer, bgp_size_t size)
2247: {
2248: u_char *pnt;
2249:
2250: /* Fetch pointer. */
2251: pnt = stream_pnt (peer->ibuf);
2252:
2253: if (BGP_DEBUG (normal, NORMAL))
2254: zlog_debug ("%s rcv CAPABILITY", peer->host);
2255:
2256: /* If peer does not have the capability, send notification. */
2257: if (! CHECK_FLAG (peer->cap, PEER_CAP_DYNAMIC_ADV))
2258: {
2259: plog_err (peer->log, "%s [Error] BGP dynamic capability is not enabled",
2260: peer->host);
2261: bgp_notify_send (peer,
2262: BGP_NOTIFY_HEADER_ERR,
2263: BGP_NOTIFY_HEADER_BAD_MESTYPE);
2264: return -1;
2265: }
2266:
2267: /* Status must be Established. */
2268: if (peer->status != Established)
2269: {
2270: plog_err (peer->log,
2271: "%s [Error] Dynamic capability packet received under status %s", peer->host, LOOKUP (bgp_status_msg, peer->status));
2272: bgp_notify_send (peer, BGP_NOTIFY_FSM_ERR, 0);
2273: return -1;
2274: }
2275:
2276: /* Parse packet. */
2277: return bgp_capability_msg_parse (peer, pnt, size);
2278: }
2279:
2280: /* BGP read utility function. */
2281: static int
2282: bgp_read_packet (struct peer *peer)
2283: {
2284: int nbytes;
2285: int readsize;
2286:
2287: readsize = peer->packet_size - stream_get_endp (peer->ibuf);
2288:
2289: /* If size is zero then return. */
2290: if (! readsize)
2291: return 0;
2292:
2293: /* Read packet from fd. */
2294: nbytes = stream_read_try (peer->ibuf, peer->fd, readsize);
2295:
2296: /* If read byte is smaller than zero then error occured. */
2297: if (nbytes < 0)
2298: {
2299: /* Transient error should retry */
2300: if (nbytes == -2)
2301: return -1;
2302:
2303: plog_err (peer->log, "%s [Error] bgp_read_packet error: %s",
2304: peer->host, safe_strerror (errno));
2305:
2306: if (peer->status == Established)
2307: {
2308: if (CHECK_FLAG (peer->sflags, PEER_STATUS_NSF_MODE))
2309: {
2310: peer->last_reset = PEER_DOWN_NSF_CLOSE_SESSION;
2311: SET_FLAG (peer->sflags, PEER_STATUS_NSF_WAIT);
2312: }
2313: else
2314: peer->last_reset = PEER_DOWN_CLOSE_SESSION;
2315: }
2316:
2317: BGP_EVENT_ADD (peer, TCP_fatal_error);
2318: return -1;
2319: }
2320:
2321: /* When read byte is zero : clear bgp peer and return */
2322: if (nbytes == 0)
2323: {
2324: if (BGP_DEBUG (events, EVENTS))
2325: plog_debug (peer->log, "%s [Event] BGP connection closed fd %d",
2326: peer->host, peer->fd);
2327:
2328: if (peer->status == Established)
2329: {
2330: if (CHECK_FLAG (peer->sflags, PEER_STATUS_NSF_MODE))
2331: {
2332: peer->last_reset = PEER_DOWN_NSF_CLOSE_SESSION;
2333: SET_FLAG (peer->sflags, PEER_STATUS_NSF_WAIT);
2334: }
2335: else
2336: peer->last_reset = PEER_DOWN_CLOSE_SESSION;
2337: }
2338:
2339: BGP_EVENT_ADD (peer, TCP_connection_closed);
2340: return -1;
2341: }
2342:
2343: /* We read partial packet. */
2344: if (stream_get_endp (peer->ibuf) != peer->packet_size)
2345: return -1;
2346:
2347: return 0;
2348: }
2349:
2350: /* Marker check. */
2351: static int
2352: bgp_marker_all_one (struct stream *s, int length)
2353: {
2354: int i;
2355:
2356: for (i = 0; i < length; i++)
2357: if (s->data[i] != 0xff)
2358: return 0;
2359:
2360: return 1;
2361: }
2362:
2363: /* Starting point of packet process function. */
2364: int
2365: bgp_read (struct thread *thread)
2366: {
2367: int ret;
2368: u_char type = 0;
2369: struct peer *peer;
2370: bgp_size_t size;
2371: char notify_data_length[2];
2372:
2373: /* Yes first of all get peer pointer. */
2374: peer = THREAD_ARG (thread);
2375: peer->t_read = NULL;
2376:
2377: /* For non-blocking IO check. */
2378: if (peer->status == Connect)
2379: {
2380: bgp_connect_check (peer);
2381: goto done;
2382: }
2383: else
2384: {
2385: if (peer->fd < 0)
2386: {
2387: zlog_err ("bgp_read peer's fd is negative value %d", peer->fd);
2388: return -1;
2389: }
2390: BGP_READ_ON (peer->t_read, bgp_read, peer->fd);
2391: }
2392:
2393: /* Read packet header to determine type of the packet */
2394: if (peer->packet_size == 0)
2395: peer->packet_size = BGP_HEADER_SIZE;
2396:
2397: if (stream_get_endp (peer->ibuf) < BGP_HEADER_SIZE)
2398: {
2399: ret = bgp_read_packet (peer);
2400:
2401: /* Header read error or partial read packet. */
2402: if (ret < 0)
2403: goto done;
2404:
2405: /* Get size and type. */
2406: stream_forward_getp (peer->ibuf, BGP_MARKER_SIZE);
2407: memcpy (notify_data_length, stream_pnt (peer->ibuf), 2);
2408: size = stream_getw (peer->ibuf);
2409: type = stream_getc (peer->ibuf);
2410:
2411: if (BGP_DEBUG (normal, NORMAL) && type != 2 && type != 0)
2412: zlog_debug ("%s rcv message type %d, length (excl. header) %d",
2413: peer->host, type, size - BGP_HEADER_SIZE);
2414:
2415: /* Marker check */
2416: if (((type == BGP_MSG_OPEN) || (type == BGP_MSG_KEEPALIVE))
2417: && ! bgp_marker_all_one (peer->ibuf, BGP_MARKER_SIZE))
2418: {
2419: bgp_notify_send (peer,
2420: BGP_NOTIFY_HEADER_ERR,
2421: BGP_NOTIFY_HEADER_NOT_SYNC);
2422: goto done;
2423: }
2424:
2425: /* BGP type check. */
2426: if (type != BGP_MSG_OPEN && type != BGP_MSG_UPDATE
2427: && type != BGP_MSG_NOTIFY && type != BGP_MSG_KEEPALIVE
2428: && type != BGP_MSG_ROUTE_REFRESH_NEW
2429: && type != BGP_MSG_ROUTE_REFRESH_OLD
2430: && type != BGP_MSG_CAPABILITY)
2431: {
2432: if (BGP_DEBUG (normal, NORMAL))
2433: plog_debug (peer->log,
2434: "%s unknown message type 0x%02x",
2435: peer->host, type);
2436: bgp_notify_send_with_data (peer,
2437: BGP_NOTIFY_HEADER_ERR,
2438: BGP_NOTIFY_HEADER_BAD_MESTYPE,
2439: &type, 1);
2440: goto done;
2441: }
2442: /* Mimimum packet length check. */
2443: if ((size < BGP_HEADER_SIZE)
2444: || (size > BGP_MAX_PACKET_SIZE)
2445: || (type == BGP_MSG_OPEN && size < BGP_MSG_OPEN_MIN_SIZE)
2446: || (type == BGP_MSG_UPDATE && size < BGP_MSG_UPDATE_MIN_SIZE)
2447: || (type == BGP_MSG_NOTIFY && size < BGP_MSG_NOTIFY_MIN_SIZE)
2448: || (type == BGP_MSG_KEEPALIVE && size != BGP_MSG_KEEPALIVE_MIN_SIZE)
2449: || (type == BGP_MSG_ROUTE_REFRESH_NEW && size < BGP_MSG_ROUTE_REFRESH_MIN_SIZE)
2450: || (type == BGP_MSG_ROUTE_REFRESH_OLD && size < BGP_MSG_ROUTE_REFRESH_MIN_SIZE)
2451: || (type == BGP_MSG_CAPABILITY && size < BGP_MSG_CAPABILITY_MIN_SIZE))
2452: {
2453: if (BGP_DEBUG (normal, NORMAL))
2454: plog_debug (peer->log,
2455: "%s bad message length - %d for %s",
2456: peer->host, size,
2457: type == 128 ? "ROUTE-REFRESH" :
2458: bgp_type_str[(int) type]);
2459: bgp_notify_send_with_data (peer,
2460: BGP_NOTIFY_HEADER_ERR,
2461: BGP_NOTIFY_HEADER_BAD_MESLEN,
2462: (u_char *) notify_data_length, 2);
2463: goto done;
2464: }
2465:
2466: /* Adjust size to message length. */
2467: peer->packet_size = size;
2468: }
2469:
2470: ret = bgp_read_packet (peer);
2471: if (ret < 0)
2472: goto done;
2473:
2474: /* Get size and type again. */
2475: size = stream_getw_from (peer->ibuf, BGP_MARKER_SIZE);
2476: type = stream_getc_from (peer->ibuf, BGP_MARKER_SIZE + 2);
2477:
2478: /* BGP packet dump function. */
2479: bgp_dump_packet (peer, type, peer->ibuf);
2480:
2481: size = (peer->packet_size - BGP_HEADER_SIZE);
2482:
2483: /* Read rest of the packet and call each sort of packet routine */
2484: switch (type)
2485: {
2486: case BGP_MSG_OPEN:
2487: peer->open_in++;
2488: bgp_open_receive (peer, size); /* XXX return value ignored! */
2489: break;
2490: case BGP_MSG_UPDATE:
2491: peer->readtime = time(NULL); /* Last read timer reset */
2492: bgp_update_receive (peer, size);
2493: break;
2494: case BGP_MSG_NOTIFY:
2495: bgp_notify_receive (peer, size);
2496: break;
2497: case BGP_MSG_KEEPALIVE:
2498: peer->readtime = time(NULL); /* Last read timer reset */
2499: bgp_keepalive_receive (peer, size);
2500: break;
2501: case BGP_MSG_ROUTE_REFRESH_NEW:
2502: case BGP_MSG_ROUTE_REFRESH_OLD:
2503: peer->refresh_in++;
2504: bgp_route_refresh_receive (peer, size);
2505: break;
2506: case BGP_MSG_CAPABILITY:
2507: peer->dynamic_cap_in++;
2508: bgp_capability_receive (peer, size);
2509: break;
2510: }
2511:
2512: /* Clear input buffer. */
2513: peer->packet_size = 0;
2514: if (peer->ibuf)
2515: stream_reset (peer->ibuf);
2516:
2517: done:
2518: if (CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
2519: {
2520: if (BGP_DEBUG (events, EVENTS))
2521: zlog_debug ("%s [Event] Accepting BGP peer delete", peer->host);
2522: peer_delete (peer);
2523: }
2524: return 0;
2525: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bgp_packet.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / bgpd