]> git.proxmox.com Git - mirror_frr.git/blob - eigrpd/eigrp_update.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #1961 from qlyoung/docuser
[mirror_frr.git] / eigrpd / eigrp_update.c
1 /*
2 * EIGRP Sending and Receiving EIGRP Update Packets.
3 * Copyright (C) 2013-2016
4 * Authors:
5 * Donnie Savage
6 * Jan Janovic
7 * Matej Perina
8 * Peter Orsag
9 * Peter Paluch
10 * Frantisek Gazo
11 * Tomas Hvorkovy
12 * Martin Kontsek
13 * Lukas Koribsky
14 *
15 * This file is part of GNU Zebra.
16 *
17 * GNU Zebra is free software; you can redistribute it and/or modify it
18 * under the terms of the GNU General Public License as published by the
19 * Free Software Foundation; either version 2, or (at your option) any
20 * later version.
21 *
22 * GNU Zebra is distributed in the hope that it will be useful, but
23 * WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25 * General Public License for more details.
26 *
27 * You should have received a copy of the GNU General Public License along
28 * with this program; see the file COPYING; if not, write to the Free Software
29 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
30 */
31
32 #include <zebra.h>
33
34 #include "thread.h"
35 #include "memory.h"
36 #include "linklist.h"
37 #include "prefix.h"
38 #include "if.h"
39 #include "table.h"
40 #include "sockunion.h"
41 #include "stream.h"
42 #include "log.h"
43 #include "sockopt.h"
44 #include "checksum.h"
45 #include "md5.h"
46 #include "vty.h"
47 #include "plist.h"
48 #include "plist_int.h"
49 #include "routemap.h"
50 #include "vty.h"
51
52 #include "eigrpd/eigrp_structs.h"
53 #include "eigrpd/eigrpd.h"
54 #include "eigrpd/eigrp_interface.h"
55 #include "eigrpd/eigrp_neighbor.h"
56 #include "eigrpd/eigrp_packet.h"
57 #include "eigrpd/eigrp_zebra.h"
58 #include "eigrpd/eigrp_vty.h"
59 #include "eigrpd/eigrp_dump.h"
60 #include "eigrpd/eigrp_macros.h"
61 #include "eigrpd/eigrp_topology.h"
62 #include "eigrpd/eigrp_fsm.h"
63 #include "eigrpd/eigrp_network.h"
64 #include "eigrpd/eigrp_memory.h"
65
66 bool eigrp_update_prefix_apply(struct eigrp *eigrp, struct eigrp_interface *ei,
67 int in, struct prefix *prefix)
68 {
69 struct access_list *alist;
70 struct prefix_list *plist;
71
72 alist = eigrp->list[in];
73 if (alist && access_list_apply(alist, prefix) == FILTER_DENY)
74 return true;
75
76 plist = eigrp->prefix[in];
77 if (plist && prefix_list_apply(plist, prefix) == PREFIX_DENY)
78 return true;
79
80 alist = ei->list[in];
81 if (alist && access_list_apply(alist, prefix) == FILTER_DENY)
82 return true;
83
84 plist = ei->prefix[in];
85 if (plist && prefix_list_apply(plist, prefix) == PREFIX_DENY)
86 return true;
87
88 return false;
89 }
90
91 /**
92 * @fn remove_received_prefix_gr
93 *
94 * @param[in] nbr_prefixes List of neighbor prefixes
95 * @param[in] recv_prefix Prefix which needs to be removed from
96 * list
97 *
98 * @return void
99 *
100 * @par
101 * Function is used for removing received prefix
102 * from list of neighbor prefixes
103 */
104 static void remove_received_prefix_gr(struct list *nbr_prefixes,
105 struct eigrp_prefix_entry *recv_prefix)
106 {
107 struct listnode *node1, *node11;
108 struct eigrp_prefix_entry *prefix = NULL;
109
110 /* iterate over all prefixes in list */
111 for (ALL_LIST_ELEMENTS(nbr_prefixes, node1, node11, prefix)) {
112 /* remove prefix from list if found */
113 if (prefix == recv_prefix) {
114 listnode_delete(nbr_prefixes, prefix);
115 }
116 }
117 }
118
119 /**
120 * @fn eigrp_update_receive_GR_ask
121 *
122 * @param[in] eigrp EIGRP process
123 * @param[in] nbr Neighbor update of who we
124 * received
125 * @param[in] nbr_prefixes Prefixes which weren't advertised
126 *
127 * @return void
128 *
129 * @par
130 * Function is used for notifying FSM about prefixes which
131 * weren't advertised by neighbor:
132 * We will send message to FSM with prefix delay set to infinity.
133 */
134 static void eigrp_update_receive_GR_ask(struct eigrp *eigrp,
135 struct eigrp_neighbor *nbr,
136 struct list *nbr_prefixes)
137 {
138 struct listnode *node1;
139 struct eigrp_prefix_entry *prefix;
140 struct eigrp_fsm_action_message fsm_msg;
141
142 /* iterate over all prefixes which weren't advertised by neighbor */
143 for (ALL_LIST_ELEMENTS_RO(nbr_prefixes, node1, prefix)) {
144 char buffer[PREFIX_STRLEN];
145 zlog_debug(
146 "GR receive: Neighbor not advertised %s",
147 prefix2str(prefix->destination, buffer, PREFIX_STRLEN));
148
149 fsm_msg.metrics = prefix->reported_metric;
150 /* set delay to MAX */
151 fsm_msg.metrics.delay = EIGRP_MAX_METRIC;
152
153 struct eigrp_nexthop_entry *entry =
154 eigrp_prefix_entry_lookup(prefix->entries, nbr);
155
156 fsm_msg.packet_type = EIGRP_OPC_UPDATE;
157 fsm_msg.eigrp = eigrp;
158 fsm_msg.data_type = EIGRP_INT;
159 fsm_msg.adv_router = nbr;
160 fsm_msg.entry = entry;
161 fsm_msg.prefix = prefix;
162
163 /* send message to FSM */
164 eigrp_fsm_event(&fsm_msg);
165 }
166 }
167
168 /*
169 * EIGRP UPDATE read function
170 */
171 void eigrp_update_receive(struct eigrp *eigrp, struct ip *iph,
172 struct eigrp_header *eigrph, struct stream *s,
173 struct eigrp_interface *ei, int size)
174 {
175 struct eigrp_neighbor *nbr;
176 struct TLV_IPv4_Internal_type *tlv;
177 struct eigrp_prefix_entry *pe;
178 struct eigrp_nexthop_entry *ne;
179 uint32_t flags;
180 uint16_t type;
181 uint16_t length;
182 uint8_t same;
183 struct prefix dest_addr;
184 uint8_t graceful_restart;
185 uint8_t graceful_restart_final;
186 struct list *nbr_prefixes = NULL;
187
188 /* increment statistics. */
189 ei->update_in++;
190
191 /* get neighbor struct */
192 nbr = eigrp_nbr_get(ei, eigrph, iph);
193
194 /* neighbor must be valid, eigrp_nbr_get creates if none existed */
195 assert(nbr);
196
197 flags = ntohl(eigrph->flags);
198
199 if (flags & EIGRP_CR_FLAG) {
200 return;
201 }
202
203 same = 0;
204 graceful_restart = 0;
205 graceful_restart_final = 0;
206 if ((nbr->recv_sequence_number) == (ntohl(eigrph->sequence)))
207 same = 1;
208
209 nbr->recv_sequence_number = ntohl(eigrph->sequence);
210 if (IS_DEBUG_EIGRP_PACKET(0, RECV))
211 zlog_debug(
212 "Processing Update size[%u] int(%s) nbr(%s) seq [%u] flags [%0x]",
213 size,
214 ifindex2ifname(nbr->ei->ifp->ifindex, VRF_DEFAULT),
215 inet_ntoa(nbr->src), nbr->recv_sequence_number, flags);
216
217
218 if ((flags == (EIGRP_INIT_FLAG + EIGRP_RS_FLAG + EIGRP_EOT_FLAG))
219 && (!same)) {
220 /* Graceful restart Update received with all routes */
221
222 zlog_info("Neighbor %s (%s) is resync: peer graceful-restart",
223 inet_ntoa(nbr->src),
224 ifindex2ifname(nbr->ei->ifp->ifindex, VRF_DEFAULT));
225
226 /* get all prefixes from neighbor from topology table */
227 nbr_prefixes = eigrp_neighbor_prefixes_lookup(eigrp, nbr);
228 graceful_restart = 1;
229 graceful_restart_final = 1;
230 } else if ((flags == (EIGRP_INIT_FLAG + EIGRP_RS_FLAG)) && (!same)) {
231 /* Graceful restart Update received, routes also in next packet
232 */
233
234 zlog_info("Neighbor %s (%s) is resync: peer graceful-restart",
235 inet_ntoa(nbr->src),
236 ifindex2ifname(nbr->ei->ifp->ifindex, VRF_DEFAULT));
237
238 /* get all prefixes from neighbor from topology table */
239 nbr_prefixes = eigrp_neighbor_prefixes_lookup(eigrp, nbr);
240 /* save prefixes to neighbor for later use */
241 nbr->nbr_gr_prefixes = nbr_prefixes;
242 graceful_restart = 1;
243 graceful_restart_final = 0;
244 } else if ((flags == (EIGRP_EOT_FLAG)) && (!same)) {
245 /* If there was INIT+RS Update packet before,
246 * consider this as GR EOT */
247
248 if (nbr->nbr_gr_prefixes != NULL) {
249 /* this is final packet of GR */
250 nbr_prefixes = nbr->nbr_gr_prefixes;
251 nbr->nbr_gr_prefixes = NULL;
252
253 graceful_restart = 1;
254 graceful_restart_final = 1;
255 }
256
257 } else if ((flags == (0)) && (!same)) {
258 /* If there was INIT+RS Update packet before,
259 * consider this as GR not final packet */
260
261 if (nbr->nbr_gr_prefixes != NULL) {
262 /* this is GR not final route packet */
263 nbr_prefixes = nbr->nbr_gr_prefixes;
264
265 graceful_restart = 1;
266 graceful_restart_final = 0;
267 }
268
269 } else if ((flags & EIGRP_INIT_FLAG)
270 && (!same)) { /* When in pending state, send INIT update only
271 if it wasn't
272 already sent before (only if init_sequence
273 is 0) */
274 if ((nbr->state == EIGRP_NEIGHBOR_PENDING)
275 && (nbr->init_sequence_number == 0))
276 eigrp_update_send_init(nbr);
277
278 if (nbr->state == EIGRP_NEIGHBOR_UP) {
279 eigrp_nbr_state_set(nbr, EIGRP_NEIGHBOR_DOWN);
280 eigrp_topology_neighbor_down(nbr->ei->eigrp, nbr);
281 nbr->recv_sequence_number = ntohl(eigrph->sequence);
282 zlog_info("Neighbor %s (%s) is down: peer restarted",
283 inet_ntoa(nbr->src),
284 ifindex2ifname(nbr->ei->ifp->ifindex,
285 VRF_DEFAULT));
286 eigrp_nbr_state_set(nbr, EIGRP_NEIGHBOR_PENDING);
287 zlog_info("Neighbor %s (%s) is pending: new adjacency",
288 inet_ntoa(nbr->src),
289 ifindex2ifname(nbr->ei->ifp->ifindex,
290 VRF_DEFAULT));
291 eigrp_update_send_init(nbr);
292 }
293 }
294
295 /*If there is topology information*/
296 while (s->endp > s->getp) {
297 type = stream_getw(s);
298 switch (type) {
299 case EIGRP_TLV_IPv4_INT:
300 stream_set_getp(s, s->getp - sizeof(uint16_t));
301
302 tlv = eigrp_read_ipv4_tlv(s);
303
304 /*searching if destination exists */
305 dest_addr.family = AF_INET;
306 dest_addr.u.prefix4 = tlv->destination;
307 dest_addr.prefixlen = tlv->prefix_length;
308 struct eigrp_prefix_entry *dest =
309 eigrp_topology_table_lookup_ipv4(
310 eigrp->topology_table, &dest_addr);
311
312 /*if exists it comes to DUAL*/
313 if (dest != NULL) {
314 /* remove received prefix from neighbor prefix
315 * list if in GR */
316 if (graceful_restart)
317 remove_received_prefix_gr(nbr_prefixes,
318 dest);
319
320 struct eigrp_fsm_action_message msg;
321 struct eigrp_nexthop_entry *entry =
322 eigrp_prefix_entry_lookup(dest->entries,
323 nbr);
324
325 msg.packet_type = EIGRP_OPC_UPDATE;
326 msg.eigrp = eigrp;
327 msg.data_type = EIGRP_INT;
328 msg.adv_router = nbr;
329 msg.metrics = tlv->metric;
330 msg.entry = entry;
331 msg.prefix = dest;
332 eigrp_fsm_event(&msg);
333 } else {
334 /*Here comes topology information save*/
335 pe = eigrp_prefix_entry_new();
336 pe->serno = eigrp->serno;
337 pe->destination =
338 (struct prefix *)prefix_ipv4_new();
339 prefix_copy(pe->destination, &dest_addr);
340 pe->af = AF_INET;
341 pe->state = EIGRP_FSM_STATE_PASSIVE;
342 pe->nt = EIGRP_TOPOLOGY_TYPE_REMOTE;
343
344 ne = eigrp_nexthop_entry_new();
345 ne->ei = ei;
346 ne->adv_router = nbr;
347 ne->reported_metric = tlv->metric;
348 ne->reported_distance = eigrp_calculate_metrics(
349 eigrp, tlv->metric);
350 /*
351 * Filtering
352 */
353 if (eigrp_update_prefix_apply(eigrp, ei,
354 EIGRP_FILTER_IN,
355 &dest_addr))
356 ne->reported_metric.delay =
357 EIGRP_MAX_METRIC;
358
359 ne->distance = eigrp_calculate_total_metrics(
360 eigrp, ne);
361
362 pe->fdistance = pe->distance = pe->rdistance =
363 ne->distance;
364 ne->prefix = pe;
365 ne->flags = EIGRP_NEXTHOP_ENTRY_SUCCESSOR_FLAG;
366
367 eigrp_prefix_entry_add(eigrp->topology_table,
368 pe);
369 eigrp_nexthop_entry_add(pe, ne);
370 pe->distance = pe->fdistance = pe->rdistance =
371 ne->distance;
372 pe->reported_metric = ne->total_metric;
373 eigrp_topology_update_node_flags(pe);
374
375 pe->req_action |= EIGRP_FSM_NEED_UPDATE;
376 listnode_add(
377 eigrp->topology_changes_internalIPV4,
378 pe);
379 }
380 eigrp_IPv4_InternalTLV_free(tlv);
381 break;
382
383 case EIGRP_TLV_IPv4_EXT:
384 /* DVS: processing of external routes needs packet and fsm work.
385 * for now, lets just not creash the box
386 */
387 default:
388 length = stream_getw(s);
389 // -2 for type, -2 for len
390 for (length -= 4; length; length--) {
391 (void)stream_getc(s);
392 }
393 }
394 }
395
396 /* ask about prefixes not present in GR update,
397 * if this is final GR packet */
398 if (graceful_restart_final) {
399 eigrp_update_receive_GR_ask(eigrp, nbr, nbr_prefixes);
400 }
401
402 /*
403 * We don't need to send separate Ack for INIT Update. INIT will be
404 * acked in EOT Update.
405 */
406 if ((nbr->state == EIGRP_NEIGHBOR_UP) && !(flags == EIGRP_INIT_FLAG)) {
407 eigrp_hello_send_ack(nbr);
408 }
409
410 eigrp_query_send_all(eigrp);
411 eigrp_update_send_all(eigrp, ei);
412
413 if (nbr_prefixes)
414 list_delete_and_null(&nbr_prefixes);
415 }
416
417 /*send EIGRP Update packet*/
418 void eigrp_update_send_init(struct eigrp_neighbor *nbr)
419 {
420 struct eigrp_packet *ep;
421 uint16_t length = EIGRP_HEADER_LEN;
422
423 ep = eigrp_packet_new(nbr->ei->ifp->mtu, nbr);
424
425 /* Prepare EIGRP INIT UPDATE header */
426 if (IS_DEBUG_EIGRP_PACKET(0, RECV))
427 zlog_debug("Enqueuing Update Init Seq [%u] Ack [%u]",
428 nbr->ei->eigrp->sequence_number,
429 nbr->recv_sequence_number);
430
431 eigrp_packet_header_init(
432 EIGRP_OPC_UPDATE, nbr->ei->eigrp, ep->s, EIGRP_INIT_FLAG,
433 nbr->ei->eigrp->sequence_number, nbr->recv_sequence_number);
434
435 // encode Authentication TLV, if needed
436 if ((nbr->ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
437 && (nbr->ei->params.auth_keychain != NULL)) {
438 length += eigrp_add_authTLV_MD5_to_stream(ep->s, nbr->ei);
439 eigrp_make_md5_digest(nbr->ei, ep->s,
440 EIGRP_AUTH_UPDATE_INIT_FLAG);
441 }
442
443 /* EIGRP Checksum */
444 eigrp_packet_checksum(nbr->ei, ep->s, length);
445
446 ep->length = length;
447 ep->dst.s_addr = nbr->src.s_addr;
448
449 /*This ack number we await from neighbor*/
450 nbr->init_sequence_number = nbr->ei->eigrp->sequence_number;
451 ep->sequence_number = nbr->ei->eigrp->sequence_number;
452 if (IS_DEBUG_EIGRP_PACKET(0, RECV))
453 zlog_debug("Enqueuing Update Init Len [%u] Seq [%u] Dest [%s]",
454 ep->length, ep->sequence_number, inet_ntoa(ep->dst));
455
456 /*Put packet to retransmission queue*/
457 eigrp_fifo_push(nbr->retrans_queue, ep);
458
459 if (nbr->retrans_queue->count == 1) {
460 eigrp_send_packet_reliably(nbr);
461 }
462 }
463
464 static void eigrp_update_place_on_nbr_queue(struct eigrp_neighbor *nbr,
465 struct eigrp_packet *ep,
466 uint32_t seq_no, int length)
467 {
468 if ((nbr->ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
469 && (nbr->ei->params.auth_keychain != NULL)) {
470 eigrp_make_md5_digest(nbr->ei, ep->s, EIGRP_AUTH_UPDATE_FLAG);
471 }
472
473 /* EIGRP Checksum */
474 eigrp_packet_checksum(nbr->ei, ep->s, length);
475
476 ep->length = length;
477 ep->dst.s_addr = nbr->src.s_addr;
478
479 /*This ack number we await from neighbor*/
480 ep->sequence_number = seq_no;
481
482 if (IS_DEBUG_EIGRP_PACKET(0, RECV))
483 zlog_debug("Enqueuing Update Init Len [%u] Seq [%u] Dest [%s]",
484 ep->length, ep->sequence_number, inet_ntoa(ep->dst));
485
486 /*Put packet to retransmission queue*/
487 eigrp_fifo_push(nbr->retrans_queue, ep);
488
489 if (nbr->retrans_queue->count == 1)
490 eigrp_send_packet_reliably(nbr);
491 }
492
493 static void eigrp_update_send_to_all_nbrs(struct eigrp_interface *ei,
494 struct eigrp_packet *ep)
495 {
496 struct listnode *node, *nnode;
497 struct eigrp_neighbor *nbr;
498 bool packet_sent = false;
499
500 for (ALL_LIST_ELEMENTS(ei->nbrs, node, nnode, nbr)) {
501 struct eigrp_packet *ep_dup;
502
503 if (nbr->state != EIGRP_NEIGHBOR_UP)
504 continue;
505
506 if (packet_sent)
507 ep_dup = eigrp_packet_duplicate(ep, NULL);
508 else
509 ep_dup = ep;
510
511 ep_dup->nbr = nbr;
512 packet_sent = true;
513 /*Put packet to retransmission queue*/
514 eigrp_fifo_push(nbr->retrans_queue, ep_dup);
515
516 if (nbr->retrans_queue->count == 1) {
517 eigrp_send_packet_reliably(nbr);
518 }
519 }
520
521 if (!packet_sent)
522 eigrp_packet_free(ep);
523 }
524
525 void eigrp_update_send_EOT(struct eigrp_neighbor *nbr)
526 {
527 struct eigrp_packet *ep;
528 uint16_t length = EIGRP_HEADER_LEN;
529 struct eigrp_nexthop_entry *te;
530 struct eigrp_prefix_entry *pe;
531 struct listnode *node2, *nnode2;
532 struct eigrp_interface *ei = nbr->ei;
533 struct eigrp *eigrp = ei->eigrp;
534 struct prefix *dest_addr;
535 uint32_t seq_no = eigrp->sequence_number;
536 uint16_t mtu = ei->ifp->mtu;
537 struct route_node *rn;
538
539 ep = eigrp_packet_new(mtu, nbr);
540
541 /* Prepare EIGRP EOT UPDATE header */
542 eigrp_packet_header_init(EIGRP_OPC_UPDATE, eigrp, ep->s, EIGRP_EOT_FLAG,
543 seq_no, nbr->recv_sequence_number);
544
545 // encode Authentication TLV, if needed
546 if ((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
547 && (ei->params.auth_keychain != NULL)) {
548 length += eigrp_add_authTLV_MD5_to_stream(ep->s, ei);
549 }
550
551 for (rn = route_top(eigrp->topology_table); rn; rn = route_next(rn)) {
552 if (!rn->info)
553 continue;
554
555 pe = rn->info;
556 for (ALL_LIST_ELEMENTS(pe->entries, node2, nnode2, te)) {
557 if (eigrp_nbr_split_horizon_check(te, ei))
558 continue;
559
560 if ((length + EIGRP_TLV_MAX_IPV4_BYTE) > mtu) {
561 eigrp_update_place_on_nbr_queue(nbr, ep, seq_no,
562 length);
563 seq_no++;
564
565 length = EIGRP_HEADER_LEN;
566 ep = eigrp_packet_new(mtu, nbr);
567 eigrp_packet_header_init(
568 EIGRP_OPC_UPDATE, nbr->ei->eigrp, ep->s,
569 EIGRP_EOT_FLAG, seq_no,
570 nbr->recv_sequence_number);
571
572 if ((ei->params.auth_type
573 == EIGRP_AUTH_TYPE_MD5)
574 && (ei->params.auth_keychain != NULL)) {
575 length +=
576 eigrp_add_authTLV_MD5_to_stream(
577 ep->s, ei);
578 }
579 }
580 /* Get destination address from prefix */
581 dest_addr = pe->destination;
582
583 /* Check if any list fits */
584 if (eigrp_update_prefix_apply(
585 eigrp, ei, EIGRP_FILTER_OUT, dest_addr))
586 continue;
587 else {
588 length += eigrp_add_internalTLV_to_stream(ep->s,
589 pe);
590 }
591 }
592 }
593
594 eigrp_update_place_on_nbr_queue(nbr, ep, seq_no, length);
595 eigrp->sequence_number = seq_no++;
596 }
597
598 void eigrp_update_send(struct eigrp_interface *ei)
599 {
600 struct eigrp_packet *ep;
601 struct listnode *node, *nnode;
602 struct eigrp_prefix_entry *pe;
603 uint8_t has_tlv;
604 struct eigrp *eigrp = ei->eigrp;
605 struct prefix *dest_addr;
606 uint32_t seq_no = eigrp->sequence_number;
607
608 if (ei->nbrs->count == 0)
609 return;
610
611 uint16_t length = EIGRP_HEADER_LEN;
612
613 ep = eigrp_packet_new(ei->ifp->mtu, NULL);
614
615 /* Prepare EIGRP INIT UPDATE header */
616 eigrp_packet_header_init(EIGRP_OPC_UPDATE, eigrp, ep->s, 0, seq_no, 0);
617
618 // encode Authentication TLV, if needed
619 if ((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
620 && (ei->params.auth_keychain != NULL)) {
621 length += eigrp_add_authTLV_MD5_to_stream(ep->s, ei);
622 }
623
624 has_tlv = 0;
625 for (ALL_LIST_ELEMENTS(ei->eigrp->topology_changes_internalIPV4, node,
626 nnode, pe)) {
627 struct eigrp_nexthop_entry *ne;
628
629 if (!(pe->req_action & EIGRP_FSM_NEED_UPDATE))
630 continue;
631
632 ne = listnode_head(pe->entries);
633 if (eigrp_nbr_split_horizon_check(ne, ei))
634 continue;
635
636 if ((length + EIGRP_TLV_MAX_IPV4_BYTE)
637 > (uint16_t)ei->ifp->mtu) {
638 if ((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
639 && (ei->params.auth_keychain != NULL)) {
640 eigrp_make_md5_digest(ei, ep->s,
641 EIGRP_AUTH_UPDATE_FLAG);
642 }
643
644 eigrp_packet_checksum(ei, ep->s, length);
645 ep->length = length;
646
647 ep->dst.s_addr = htonl(EIGRP_MULTICAST_ADDRESS);
648
649 ep->sequence_number = seq_no;
650 seq_no++;
651 eigrp_update_send_to_all_nbrs(ei, ep);
652
653 length = EIGRP_HEADER_LEN;
654 ep = eigrp_packet_new(ei->ifp->mtu, NULL);
655 eigrp_packet_header_init(EIGRP_OPC_UPDATE, eigrp, ep->s,
656 0, seq_no, 0);
657 if ((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
658 && (ei->params.auth_keychain != NULL)) {
659 length += eigrp_add_authTLV_MD5_to_stream(ep->s,
660 ei);
661 }
662 has_tlv = 0;
663 }
664 /* Get destination address from prefix */
665 dest_addr = pe->destination;
666
667 if (eigrp_update_prefix_apply(eigrp, ei, EIGRP_FILTER_OUT,
668 dest_addr)) {
669 // pe->reported_metric.delay = EIGRP_MAX_METRIC;
670 continue;
671 } else {
672 length += eigrp_add_internalTLV_to_stream(ep->s, pe);
673 has_tlv = 1;
674 }
675 }
676
677 if (!has_tlv) {
678 eigrp_packet_free(ep);
679 return;
680 }
681
682 if ((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
683 && (ei->params.auth_keychain != NULL)) {
684 eigrp_make_md5_digest(ei, ep->s, EIGRP_AUTH_UPDATE_FLAG);
685 }
686
687 /* EIGRP Checksum */
688 eigrp_packet_checksum(ei, ep->s, length);
689 ep->length = length;
690
691 ep->dst.s_addr = htonl(EIGRP_MULTICAST_ADDRESS);
692
693 /*This ack number we await from neighbor*/
694 ep->sequence_number = eigrp->sequence_number;
695
696 if (IS_DEBUG_EIGRP_PACKET(0, RECV))
697 zlog_debug("Enqueuing Update length[%u] Seq [%u]", length,
698 ep->sequence_number);
699
700 eigrp_update_send_to_all_nbrs(ei, ep);
701 ei->eigrp->sequence_number = seq_no++;
702 }
703
704 void eigrp_update_send_all(struct eigrp *eigrp,
705 struct eigrp_interface *exception)
706 {
707 struct eigrp_interface *iface;
708 struct listnode *node, *node2, *nnode2;
709 struct eigrp_prefix_entry *pe;
710
711 for (ALL_LIST_ELEMENTS_RO(eigrp->eiflist, node, iface)) {
712 if (iface != exception) {
713 eigrp_update_send(iface);
714 }
715 }
716
717 for (ALL_LIST_ELEMENTS(eigrp->topology_changes_internalIPV4, node2,
718 nnode2, pe)) {
719 if (pe->req_action & EIGRP_FSM_NEED_UPDATE) {
720 pe->req_action &= ~EIGRP_FSM_NEED_UPDATE;
721 listnode_delete(eigrp->topology_changes_internalIPV4,
722 pe);
723 }
724 }
725 }
726
727 /**
728 * @fn eigrp_update_send_GR_part
729 *
730 * @param[in] nbr contains neighbor who would receive
731 * Graceful
732 * restart
733 *
734 * @return void
735 *
736 * @par
737 * Function used for sending Graceful restart Update packet
738 * and if there are multiple chunks, send only one of them.
739 * It is called from thread. Do not call it directly.
740 *
741 * Uses nbr_gr_packet_type from neighbor.
742 */
743 static void eigrp_update_send_GR_part(struct eigrp_neighbor *nbr)
744 {
745 struct eigrp_packet *ep;
746 uint16_t length = EIGRP_HEADER_LEN;
747 struct eigrp_prefix_entry *pe;
748 struct prefix *dest_addr;
749 struct eigrp_interface *ei = nbr->ei;
750 struct eigrp *eigrp = ei->eigrp;
751 struct list *prefixes;
752 uint32_t flags;
753 unsigned int send_prefixes;
754 struct route_node *rn;
755
756 /* get prefixes to send to neighbor */
757 prefixes = nbr->nbr_gr_prefixes_send;
758
759 send_prefixes = 0;
760 length = EIGRP_HEADER_LEN;
761
762 /* if there already were last packet chunk, we won't continue */
763 if (nbr->nbr_gr_packet_type == EIGRP_PACKET_PART_LAST)
764 return;
765
766 /* if this is first packet chunk, we need to decide,
767 * if there will be one or more chunks */
768 if (nbr->nbr_gr_packet_type == EIGRP_PACKET_PART_FIRST) {
769 if (prefixes->count <= EIGRP_TLV_MAX_IPv4) {
770 /* there will be only one chunk */
771 flags = EIGRP_INIT_FLAG + EIGRP_RS_FLAG
772 + EIGRP_EOT_FLAG;
773 nbr->nbr_gr_packet_type = EIGRP_PACKET_PART_LAST;
774 } else {
775 /* there will be more chunks */
776 flags = EIGRP_INIT_FLAG + EIGRP_RS_FLAG;
777 nbr->nbr_gr_packet_type = EIGRP_PACKET_PART_NA;
778 }
779 } else {
780 /* this is not first chunk, and we need to decide,
781 * if there will be more chunks */
782 if (prefixes->count <= EIGRP_TLV_MAX_IPv4) {
783 /* this is last chunk */
784 flags = EIGRP_EOT_FLAG;
785 nbr->nbr_gr_packet_type = EIGRP_PACKET_PART_LAST;
786 } else {
787 /* there will be more chunks */
788 flags = 0;
789 nbr->nbr_gr_packet_type = EIGRP_PACKET_PART_NA;
790 }
791 }
792
793 ep = eigrp_packet_new(ei->ifp->mtu, nbr);
794
795 /* Prepare EIGRP Graceful restart UPDATE header */
796 eigrp_packet_header_init(EIGRP_OPC_UPDATE, eigrp, ep->s, flags,
797 eigrp->sequence_number,
798 nbr->recv_sequence_number);
799
800 // encode Authentication TLV, if needed
801 if ((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
802 && (ei->params.auth_keychain != NULL)) {
803 length += eigrp_add_authTLV_MD5_to_stream(ep->s, ei);
804 }
805
806 for (rn = route_top(eigrp->topology_table); rn; rn = route_next(rn)) {
807 if (!rn->info)
808 continue;
809
810 pe = rn->info;
811 /*
812 * Filtering
813 */
814 dest_addr = pe->destination;
815
816 if (eigrp_update_prefix_apply(eigrp, ei, EIGRP_FILTER_OUT,
817 dest_addr)) {
818 /* do not send filtered route */
819 zlog_info("Filtered prefix %s won't be sent out.",
820 inet_ntoa(dest_addr->u.prefix4));
821 } else {
822 /* sending route which wasn't filtered */
823 length += eigrp_add_internalTLV_to_stream(ep->s, pe);
824 send_prefixes++;
825 }
826
827 /*
828 * This makes no sense, Filter out then filter in???
829 * Look into this more - DBS
830 */
831 if (eigrp_update_prefix_apply(eigrp, ei, EIGRP_FILTER_IN,
832 dest_addr)) {
833 /* do not send filtered route */
834 zlog_info("Filtered prefix %s will be removed.",
835 inet_ntoa(dest_addr->u.prefix4));
836
837 /* prepare message for FSM */
838 struct eigrp_fsm_action_message fsm_msg;
839
840 struct eigrp_nexthop_entry *entry =
841 eigrp_prefix_entry_lookup(pe->entries, nbr);
842
843 fsm_msg.packet_type = EIGRP_OPC_UPDATE;
844 fsm_msg.eigrp = eigrp;
845 fsm_msg.data_type = EIGRP_INT;
846 fsm_msg.adv_router = nbr;
847 fsm_msg.metrics = pe->reported_metric;
848 /* Set delay to MAX */
849 fsm_msg.metrics.delay = EIGRP_MAX_METRIC;
850 fsm_msg.entry = entry;
851 fsm_msg.prefix = pe;
852
853 /* send message to FSM */
854 eigrp_fsm_event(&fsm_msg);
855 }
856
857 /* NULL the pointer */
858 dest_addr = NULL;
859
860 /* delete processed prefix from list */
861 listnode_delete(prefixes, pe);
862
863 /* if there are enough prefixes, send packet */
864 if (send_prefixes >= EIGRP_TLV_MAX_IPv4)
865 break;
866 }
867
868 /* compute Auth digest */
869 if ((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
870 && (ei->params.auth_keychain != NULL)) {
871 eigrp_make_md5_digest(ei, ep->s, EIGRP_AUTH_UPDATE_FLAG);
872 }
873
874 /* EIGRP Checksum */
875 eigrp_packet_checksum(ei, ep->s, length);
876
877 ep->length = length;
878 ep->dst.s_addr = nbr->src.s_addr;
879
880 /*This ack number we await from neighbor*/
881 ep->sequence_number = eigrp->sequence_number;
882
883 if (IS_DEBUG_EIGRP_PACKET(0, RECV))
884 zlog_debug("Enqueuing Update Init Len [%u] Seq [%u] Dest [%s]",
885 ep->length, ep->sequence_number, inet_ntoa(ep->dst));
886
887 /*Put packet to retransmission queue*/
888 eigrp_fifo_push(nbr->retrans_queue, ep);
889
890 if (nbr->retrans_queue->count == 1) {
891 eigrp_send_packet_reliably(nbr);
892 }
893 }
894
895 /**
896 * @fn eigrp_update_send_GR_thread
897 *
898 * @param[in] thread contains neighbor who would receive
899 * Graceful restart
900 *
901 * @return int always 0
902 *
903 * @par
904 * Function used for sending Graceful restart Update packet
905 * in thread, it is prepared for multiple chunks of packet.
906 *
907 * Uses nbr_gr_packet_type and t_nbr_send_gr from neighbor.
908 */
909 int eigrp_update_send_GR_thread(struct thread *thread)
910 {
911 struct eigrp_neighbor *nbr;
912
913 /* get argument from thread */
914 nbr = THREAD_ARG(thread);
915 /* remove this thread pointer */
916 nbr->t_nbr_send_gr = NULL;
917
918 /* if there is packet waiting in queue,
919 * schedule this thread again with small delay */
920 if (nbr->retrans_queue->count > 0) {
921 nbr->t_nbr_send_gr = NULL;
922 thread_add_timer_msec(master, eigrp_update_send_GR_thread, nbr,
923 10, &nbr->t_nbr_send_gr);
924 return 0;
925 }
926
927 /* send GR EIGRP packet chunk */
928 eigrp_update_send_GR_part(nbr);
929
930 /* if it wasn't last chunk, schedule this thread again */
931 if (nbr->nbr_gr_packet_type != EIGRP_PACKET_PART_LAST) {
932 thread_execute(master, eigrp_update_send_GR_thread, nbr, 0);
933 nbr->t_nbr_send_gr = NULL;
934 }
935
936 return 0;
937 }
938
939 /**
940 * @fn eigrp_update_send_GR
941 *
942 * @param[in] nbr Neighbor who would receive
943 * Graceful
944 * restart
945 * @param[in] gr_type Who executed Graceful restart
946 * @param[in] vty Virtual terminal for log output
947 *
948 * @return void
949 *
950 * @par
951 * Function used for sending Graceful restart Update packet:
952 * Creates Update packet with INIT, RS, EOT flags and include
953 * all route except those filtered
954 */
955 void eigrp_update_send_GR(struct eigrp_neighbor *nbr, enum GR_type gr_type,
956 struct vty *vty)
957 {
958 struct eigrp_prefix_entry *pe2;
959 struct list *prefixes;
960 struct route_node *rn;
961 struct eigrp_interface *ei = nbr->ei;
962 struct eigrp *eigrp = ei->eigrp;
963
964 if (gr_type == EIGRP_GR_FILTER) {
965 /* function was called after applying filtration */
966 zlog_info(
967 "Neighbor %s (%s) is resync: route configuration changed",
968 inet_ntoa(nbr->src),
969 ifindex2ifname(ei->ifp->ifindex, VRF_DEFAULT));
970 } else if (gr_type == EIGRP_GR_MANUAL) {
971 /* Graceful restart was called manually */
972 zlog_info("Neighbor %s (%s) is resync: manually cleared",
973 inet_ntoa(nbr->src),
974 ifindex2ifname(ei->ifp->ifindex, VRF_DEFAULT));
975
976 if (vty != NULL) {
977 vty_time_print(vty, 0);
978 vty_out(vty,
979 "Neighbor %s (%s) is resync: manually cleared\n",
980 inet_ntoa(nbr->src),
981 ifindex2ifname(ei->ifp->ifindex, VRF_DEFAULT));
982 }
983 }
984
985 prefixes = list_new();
986 /* add all prefixes from topology table to list */
987 for (rn = route_top(eigrp->topology_table); rn; rn = route_next(rn)) {
988 if (!rn->info)
989 continue;
990
991 pe2 = rn->info;
992 listnode_add(prefixes, pe2);
993 }
994
995 /* save prefixes to neighbor */
996 nbr->nbr_gr_prefixes_send = prefixes;
997 /* indicate, that this is first GR Update packet chunk */
998 nbr->nbr_gr_packet_type = EIGRP_PACKET_PART_FIRST;
999 /* execute packet sending in thread */
1000 thread_execute(master, eigrp_update_send_GR_thread, nbr, 0);
1001 nbr->t_nbr_send_gr = NULL;
1002 }
1003
1004 /**
1005 * @fn eigrp_update_send_interface_GR
1006 *
1007 * @param[in] ei Interface to neighbors of which
1008 * the
1009 * GR
1010 * is sent
1011 * @param[in] gr_type Who executed Graceful restart
1012 * @param[in] vty Virtual terminal for log output
1013 *
1014 * @return void
1015 *
1016 * @par
1017 * Function used for sending Graceful restart Update packet
1018 * to all neighbors on specified interface.
1019 */
1020 void eigrp_update_send_interface_GR(struct eigrp_interface *ei,
1021 enum GR_type gr_type, struct vty *vty)
1022 {
1023 struct listnode *node;
1024 struct eigrp_neighbor *nbr;
1025
1026 /* iterate over all neighbors on eigrp interface */
1027 for (ALL_LIST_ELEMENTS_RO(ei->nbrs, node, nbr)) {
1028 /* send GR to neighbor */
1029 eigrp_update_send_GR(nbr, gr_type, vty);
1030 }
1031 }
1032
1033 /**
1034 * @fn eigrp_update_send_process_GR
1035 *
1036 * @param[in] eigrp EIGRP process
1037 * @param[in] gr_type Who executed Graceful restart
1038 * @param[in] vty Virtual terminal for log output
1039 *
1040 * @return void
1041 *
1042 * @par
1043 * Function used for sending Graceful restart Update packet
1044 * to all neighbors in eigrp process.
1045 */
1046 void eigrp_update_send_process_GR(struct eigrp *eigrp, enum GR_type gr_type,
1047 struct vty *vty)
1048 {
1049 struct listnode *node;
1050 struct eigrp_interface *ei;
1051
1052 /* iterate over all eigrp interfaces */
1053 for (ALL_LIST_ELEMENTS_RO(eigrp->eiflist, node, ei)) {
1054 /* send GR to all neighbors on interface */
1055 eigrp_update_send_interface_GR(ei, gr_type, vty);
1056 }
1057 }
FRRouting mirror