]> git.proxmox.com Git - mirror_frr.git/blob - ospfd/ospf_packet.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ospfd: print extra LSA information in some log messages
[mirror_frr.git] / ospfd / ospf_packet.c
1 /*
2 * OSPF Sending and Receiving OSPF Packets.
3 * Copyright (C) 1999, 2000 Toshiaki Takada
4 *
5 * This file is part of GNU Zebra.
6 *
7 * GNU Zebra is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
10 * later version.
11 *
12 * GNU Zebra is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <zebra.h>
23
24 #include "monotime.h"
25 #include "thread.h"
26 #include "memory.h"
27 #include "linklist.h"
28 #include "prefix.h"
29 #include "if.h"
30 #include "table.h"
31 #include "sockunion.h"
32 #include "stream.h"
33 #include "log.h"
34 #include "sockopt.h"
35 #include "checksum.h"
36 #ifdef CRYPTO_INTERNAL
37 #include "md5.h"
38 #endif
39 #include "vrf.h"
40 #include "lib_errors.h"
41
42 #include "ospfd/ospfd.h"
43 #include "ospfd/ospf_network.h"
44 #include "ospfd/ospf_interface.h"
45 #include "ospfd/ospf_ism.h"
46 #include "ospfd/ospf_asbr.h"
47 #include "ospfd/ospf_lsa.h"
48 #include "ospfd/ospf_lsdb.h"
49 #include "ospfd/ospf_neighbor.h"
50 #include "ospfd/ospf_nsm.h"
51 #include "ospfd/ospf_packet.h"
52 #include "ospfd/ospf_spf.h"
53 #include "ospfd/ospf_flood.h"
54 #include "ospfd/ospf_dump.h"
55 #include "ospfd/ospf_errors.h"
56 #include "ospfd/ospf_zebra.h"
57 #include "ospfd/ospf_gr_helper.h"
58
59 /*
60 * OSPF Fragmentation / fragmented writes
61 *
62 * ospfd can support writing fragmented packets, for cases where
63 * kernel will not fragment IP_HDRINCL and/or multicast destined
64 * packets (ie TTBOMK all kernels, BSD, SunOS, Linux). However,
65 * SunOS, probably BSD too, clobber the user supplied IP ID and IP
66 * flags fields, hence user-space fragmentation will not work.
67 * Only Linux is known to leave IP header unmolested.
68 * Further, fragmentation really should be done the kernel, which already
69 * supports it, and which avoids nasty IP ID state problems.
70 *
71 * Fragmentation of OSPF packets can be required on networks with router
72 * with many many interfaces active in one area, or on networks with links
73 * with low MTUs.
74 */
75 #ifdef GNU_LINUX
76 #define WANT_OSPF_WRITE_FRAGMENT
77 #endif
78
79 /* Packet Type String. */
80 const struct message ospf_packet_type_str[] = {
81 {OSPF_MSG_HELLO, "Hello"},
82 {OSPF_MSG_DB_DESC, "Database Description"},
83 {OSPF_MSG_LS_REQ, "Link State Request"},
84 {OSPF_MSG_LS_UPD, "Link State Update"},
85 {OSPF_MSG_LS_ACK, "Link State Acknowledgment"},
86 {0}};
87
88 /* Minimum (besides OSPF_HEADER_SIZE) lengths for OSPF packets of
89 particular types, offset is the "type" field of a packet. */
90 static const uint16_t ospf_packet_minlen[] = {
91 0,
92 OSPF_HELLO_MIN_SIZE,
93 OSPF_DB_DESC_MIN_SIZE,
94 OSPF_LS_REQ_MIN_SIZE,
95 OSPF_LS_UPD_MIN_SIZE,
96 OSPF_LS_ACK_MIN_SIZE,
97 };
98
99 /* Minimum (besides OSPF_LSA_HEADER_SIZE) lengths for LSAs of particular
100 types, offset is the "LSA type" field. */
101 static const uint16_t ospf_lsa_minlen[] = {
102 0,
103 OSPF_ROUTER_LSA_MIN_SIZE,
104 OSPF_NETWORK_LSA_MIN_SIZE,
105 OSPF_SUMMARY_LSA_MIN_SIZE,
106 OSPF_SUMMARY_LSA_MIN_SIZE,
107 OSPF_AS_EXTERNAL_LSA_MIN_SIZE,
108 0,
109 OSPF_AS_EXTERNAL_LSA_MIN_SIZE,
110 0,
111 0,
112 0,
113 0,
114 };
115
116 /* for ospf_check_auth() */
117 static int ospf_check_sum(struct ospf_header *);
118
119 /* OSPF authentication checking function */
120 static int ospf_auth_type(struct ospf_interface *oi)
121 {
122 int auth_type;
123
124 if (OSPF_IF_PARAM(oi, auth_type) == OSPF_AUTH_NOTSET)
125 auth_type = oi->area->auth_type;
126 else
127 auth_type = OSPF_IF_PARAM(oi, auth_type);
128
129 /* Handle case where MD5 key list is not configured aka Cisco */
130 if (auth_type == OSPF_AUTH_CRYPTOGRAPHIC
131 && list_isempty(OSPF_IF_PARAM(oi, auth_crypt)))
132 return OSPF_AUTH_NULL;
133
134 return auth_type;
135 }
136
137 static struct ospf_packet *ospf_packet_new(size_t size)
138 {
139 struct ospf_packet *new;
140
141 new = XCALLOC(MTYPE_OSPF_PACKET, sizeof(struct ospf_packet));
142 new->s = stream_new(size);
143
144 return new;
145 }
146
147 void ospf_packet_free(struct ospf_packet *op)
148 {
149 if (op->s)
150 stream_free(op->s);
151
152 XFREE(MTYPE_OSPF_PACKET, op);
153 }
154
155 struct ospf_fifo *ospf_fifo_new(void)
156 {
157 struct ospf_fifo *new;
158
159 new = XCALLOC(MTYPE_OSPF_FIFO, sizeof(struct ospf_fifo));
160 return new;
161 }
162
163 /* Add new packet to fifo. */
164 void ospf_fifo_push(struct ospf_fifo *fifo, struct ospf_packet *op)
165 {
166 if (fifo->tail)
167 fifo->tail->next = op;
168 else
169 fifo->head = op;
170
171 fifo->tail = op;
172
173 fifo->count++;
174 }
175
176 /* Add new packet to head of fifo. */
177 static void ospf_fifo_push_head(struct ospf_fifo *fifo, struct ospf_packet *op)
178 {
179 op->next = fifo->head;
180
181 if (fifo->tail == NULL)
182 fifo->tail = op;
183
184 fifo->head = op;
185
186 fifo->count++;
187 }
188
189 /* Delete first packet from fifo. */
190 struct ospf_packet *ospf_fifo_pop(struct ospf_fifo *fifo)
191 {
192 struct ospf_packet *op;
193
194 op = fifo->head;
195
196 if (op) {
197 fifo->head = op->next;
198
199 if (fifo->head == NULL)
200 fifo->tail = NULL;
201
202 fifo->count--;
203 }
204
205 return op;
206 }
207
208 /* Return first fifo entry. */
209 struct ospf_packet *ospf_fifo_head(struct ospf_fifo *fifo)
210 {
211 return fifo->head;
212 }
213
214 /* Flush ospf packet fifo. */
215 void ospf_fifo_flush(struct ospf_fifo *fifo)
216 {
217 struct ospf_packet *op;
218 struct ospf_packet *next;
219
220 for (op = fifo->head; op; op = next) {
221 next = op->next;
222 ospf_packet_free(op);
223 }
224 fifo->head = fifo->tail = NULL;
225 fifo->count = 0;
226 }
227
228 /* Free ospf packet fifo. */
229 void ospf_fifo_free(struct ospf_fifo *fifo)
230 {
231 ospf_fifo_flush(fifo);
232
233 XFREE(MTYPE_OSPF_FIFO, fifo);
234 }
235
236 static void ospf_packet_add(struct ospf_interface *oi, struct ospf_packet *op)
237 {
238 /* Add packet to end of queue. */
239 ospf_fifo_push(oi->obuf, op);
240
241 /* Debug of packet fifo*/
242 /* ospf_fifo_debug (oi->obuf); */
243 }
244
245 static void ospf_packet_add_top(struct ospf_interface *oi,
246 struct ospf_packet *op)
247 {
248 /* Add packet to head of queue. */
249 ospf_fifo_push_head(oi->obuf, op);
250
251 /* Debug of packet fifo*/
252 /* ospf_fifo_debug (oi->obuf); */
253 }
254
255 static void ospf_packet_delete(struct ospf_interface *oi)
256 {
257 struct ospf_packet *op;
258
259 op = ospf_fifo_pop(oi->obuf);
260
261 if (op)
262 ospf_packet_free(op);
263 }
264
265 static struct ospf_packet *ospf_packet_dup(struct ospf_packet *op)
266 {
267 struct ospf_packet *new;
268
269 if (stream_get_endp(op->s) != op->length)
270 /* XXX size_t */
271 zlog_debug(
272 "ospf_packet_dup stream %lu ospf_packet %u size mismatch",
273 (unsigned long)STREAM_SIZE(op->s), op->length);
274
275 /* Reserve space for MD5 authentication that may be added later. */
276 new = ospf_packet_new(stream_get_endp(op->s) + OSPF_AUTH_MD5_SIZE);
277 stream_copy(new->s, op->s);
278
279 new->dst = op->dst;
280 new->length = op->length;
281
282 return new;
283 }
284
285 /* XXX inline */
286 static unsigned int ospf_packet_authspace(struct ospf_interface *oi)
287 {
288 int auth = 0;
289
290 if (ospf_auth_type(oi) == OSPF_AUTH_CRYPTOGRAPHIC)
291 auth = OSPF_AUTH_MD5_SIZE;
292
293 return auth;
294 }
295
296 static unsigned int ospf_packet_max(struct ospf_interface *oi)
297 {
298 int max;
299
300 max = oi->ifp->mtu - ospf_packet_authspace(oi);
301
302 max -= (OSPF_HEADER_SIZE + sizeof(struct ip));
303
304 return max;
305 }
306
307
308 static int ospf_check_md5_digest(struct ospf_interface *oi,
309 struct ospf_header *ospfh)
310 {
311 #ifdef CRYPTO_OPENSSL
312 EVP_MD_CTX *ctx;
313 #elif CRYPTO_INTERNAL
314 MD5_CTX ctx;
315 #endif
316 unsigned char digest[OSPF_AUTH_MD5_SIZE];
317 struct crypt_key *ck;
318 struct ospf_neighbor *nbr;
319 uint16_t length = ntohs(ospfh->length);
320
321 /* Get secret key. */
322 ck = ospf_crypt_key_lookup(OSPF_IF_PARAM(oi, auth_crypt),
323 ospfh->u.crypt.key_id);
324 if (ck == NULL) {
325 flog_warn(EC_OSPF_MD5, "interface %s: ospf_check_md5 no key %d",
326 IF_NAME(oi), ospfh->u.crypt.key_id);
327 return 0;
328 }
329
330 /* check crypto seqnum. */
331 nbr = ospf_nbr_lookup_by_routerid(oi->nbrs, &ospfh->router_id);
332
333 if (nbr
334 && ntohl(nbr->crypt_seqnum) > ntohl(ospfh->u.crypt.crypt_seqnum)) {
335 flog_warn(
336 EC_OSPF_MD5,
337 "interface %s: ospf_check_md5 bad sequence %d (expect %d)",
338 IF_NAME(oi), ntohl(ospfh->u.crypt.crypt_seqnum),
339 ntohl(nbr->crypt_seqnum));
340 return 0;
341 }
342
343 /* Generate a digest for the ospf packet - their digest + our digest. */
344 #ifdef CRYPTO_OPENSSL
345 unsigned int md5_size = OSPF_AUTH_MD5_SIZE;
346 ctx = EVP_MD_CTX_new();
347 EVP_DigestInit(ctx, EVP_md5());
348 EVP_DigestUpdate(ctx, ospfh, length);
349 EVP_DigestUpdate(ctx, ck->auth_key, OSPF_AUTH_MD5_SIZE);
350 EVP_DigestFinal(ctx, digest, &md5_size);
351 EVP_MD_CTX_free(ctx);
352 #elif CRYPTO_INTERNAL
353 memset(&ctx, 0, sizeof(ctx));
354 MD5Init(&ctx);
355 MD5Update(&ctx, ospfh, length);
356 MD5Update(&ctx, ck->auth_key, OSPF_AUTH_MD5_SIZE);
357 MD5Final(digest, &ctx);
358 #endif
359
360 /* compare the two */
361 if (memcmp((caddr_t)ospfh + length, digest, OSPF_AUTH_MD5_SIZE)) {
362 flog_warn(EC_OSPF_MD5,
363 "interface %s: ospf_check_md5 checksum mismatch",
364 IF_NAME(oi));
365 return 0;
366 }
367
368 /* save neighbor's crypt_seqnum */
369 if (nbr)
370 nbr->crypt_seqnum = ospfh->u.crypt.crypt_seqnum;
371 return 1;
372 }
373
374 /* This function is called from ospf_write(), it will detect the
375 authentication scheme and if it is MD5, it will change the sequence
376 and update the MD5 digest. */
377 static int ospf_make_md5_digest(struct ospf_interface *oi,
378 struct ospf_packet *op)
379 {
380 struct ospf_header *ospfh;
381 unsigned char digest[OSPF_AUTH_MD5_SIZE] = {0};
382 #ifdef CRYPTO_OPENSSL
383 EVP_MD_CTX *ctx;
384 #elif CRYPTO_INTERNAL
385 MD5_CTX ctx;
386 #endif
387 void *ibuf;
388 uint32_t t;
389 struct crypt_key *ck;
390 const uint8_t *auth_key;
391
392 ibuf = STREAM_DATA(op->s);
393 ospfh = (struct ospf_header *)ibuf;
394
395 if (ntohs(ospfh->auth_type) != OSPF_AUTH_CRYPTOGRAPHIC)
396 return 0;
397
398 /* We do this here so when we dup a packet, we don't have to
399 waste CPU rewriting other headers.
400
401 Note that quagga_time /deliberately/ is not used here */
402 t = (time(NULL) & 0xFFFFFFFF);
403 if (t > oi->crypt_seqnum)
404 oi->crypt_seqnum = t;
405 else
406 oi->crypt_seqnum++;
407
408 ospfh->u.crypt.crypt_seqnum = htonl(oi->crypt_seqnum);
409
410 /* Get MD5 Authentication key from auth_key list. */
411 if (list_isempty(OSPF_IF_PARAM(oi, auth_crypt)))
412 auth_key = (const uint8_t *)digest;
413 else {
414 ck = listgetdata(listtail(OSPF_IF_PARAM(oi, auth_crypt)));
415 auth_key = ck->auth_key;
416 }
417
418 /* Generate a digest for the entire packet + our secret key. */
419 #ifdef CRYPTO_OPENSSL
420 unsigned int md5_size = OSPF_AUTH_MD5_SIZE;
421 ctx = EVP_MD_CTX_new();
422 EVP_DigestInit(ctx, EVP_md5());
423 EVP_DigestUpdate(ctx, ibuf, ntohs(ospfh->length));
424 EVP_DigestUpdate(ctx, auth_key, OSPF_AUTH_MD5_SIZE);
425 EVP_DigestFinal(ctx, digest, &md5_size);
426 EVP_MD_CTX_free(ctx);
427 #elif CRYPTO_INTERNAL
428 memset(&ctx, 0, sizeof(ctx));
429 MD5Init(&ctx);
430 MD5Update(&ctx, ibuf, ntohs(ospfh->length));
431 MD5Update(&ctx, auth_key, OSPF_AUTH_MD5_SIZE);
432 MD5Final(digest, &ctx);
433 #endif
434
435 /* Append md5 digest to the end of the stream. */
436 stream_put(op->s, digest, OSPF_AUTH_MD5_SIZE);
437
438 /* We do *NOT* increment the OSPF header length. */
439 op->length = ntohs(ospfh->length) + OSPF_AUTH_MD5_SIZE;
440
441 if (stream_get_endp(op->s) != op->length)
442 /* XXX size_t */
443 flog_warn(
444 EC_OSPF_MD5,
445 "ospf_make_md5_digest: length mismatch stream %lu ospf_packet %u",
446 (unsigned long)stream_get_endp(op->s), op->length);
447
448 return OSPF_AUTH_MD5_SIZE;
449 }
450
451
452 static int ospf_ls_req_timer(struct thread *thread)
453 {
454 struct ospf_neighbor *nbr;
455
456 nbr = THREAD_ARG(thread);
457 nbr->t_ls_req = NULL;
458
459 /* Send Link State Request. */
460 if (ospf_ls_request_count(nbr))
461 ospf_ls_req_send(nbr);
462
463 /* Set Link State Request retransmission timer. */
464 OSPF_NSM_TIMER_ON(nbr->t_ls_req, ospf_ls_req_timer, nbr->v_ls_req);
465
466 return 0;
467 }
468
469 void ospf_ls_req_event(struct ospf_neighbor *nbr)
470 {
471 thread_cancel(&nbr->t_ls_req);
472 thread_add_event(master, ospf_ls_req_timer, nbr, 0, &nbr->t_ls_req);
473 }
474
475 /* Cyclic timer function. Fist registered in ospf_nbr_new () in
476 ospf_neighbor.c */
477 int ospf_ls_upd_timer(struct thread *thread)
478 {
479 struct ospf_neighbor *nbr;
480
481 nbr = THREAD_ARG(thread);
482 nbr->t_ls_upd = NULL;
483
484 /* Send Link State Update. */
485 if (ospf_ls_retransmit_count(nbr) > 0) {
486 struct list *update;
487 struct ospf_lsdb *lsdb;
488 int i;
489 int retransmit_interval;
490
491 retransmit_interval =
492 OSPF_IF_PARAM(nbr->oi, retransmit_interval);
493
494 lsdb = &nbr->ls_rxmt;
495 update = list_new();
496
497 for (i = OSPF_MIN_LSA; i < OSPF_MAX_LSA; i++) {
498 struct route_table *table = lsdb->type[i].db;
499 struct route_node *rn;
500
501 for (rn = route_top(table); rn; rn = route_next(rn)) {
502 struct ospf_lsa *lsa;
503
504 if ((lsa = rn->info) != NULL) {
505 /* Don't retransmit an LSA if we
506 received it within
507 the last RxmtInterval seconds - this
508 is to allow the
509 neighbour a chance to acknowledge the
510 LSA as it may
511 have ben just received before the
512 retransmit timer
513 fired. This is a small tweak to what
514 is in the RFC,
515 but it will cut out out a lot of
516 retransmit traffic
517 - MAG */
518 if (monotime_since(&lsa->tv_recv, NULL)
519 >= retransmit_interval * 1000000LL)
520 listnode_add(update, rn->info);
521 }
522 }
523 }
524
525 if (listcount(update) > 0)
526 ospf_ls_upd_send(nbr, update, OSPF_SEND_PACKET_DIRECT,
527 0);
528 list_delete(&update);
529 }
530
531 /* Set LS Update retransmission timer. */
532 OSPF_NSM_TIMER_ON(nbr->t_ls_upd, ospf_ls_upd_timer, nbr->v_ls_upd);
533
534 return 0;
535 }
536
537 int ospf_ls_ack_timer(struct thread *thread)
538 {
539 struct ospf_interface *oi;
540
541 oi = THREAD_ARG(thread);
542 oi->t_ls_ack = NULL;
543
544 /* Send Link State Acknowledgment. */
545 if (listcount(oi->ls_ack) > 0)
546 ospf_ls_ack_send_delayed(oi);
547
548 /* Set LS Ack timer. */
549 OSPF_ISM_TIMER_ON(oi->t_ls_ack, ospf_ls_ack_timer, oi->v_ls_ack);
550
551 return 0;
552 }
553
554 #ifdef WANT_OSPF_WRITE_FRAGMENT
555 static void ospf_write_frags(int fd, struct ospf_packet *op, struct ip *iph,
556 struct msghdr *msg, unsigned int maxdatasize,
557 unsigned int mtu, int flags, uint8_t type)
558 {
559 #define OSPF_WRITE_FRAG_SHIFT 3
560 uint16_t offset;
561 struct iovec *iovp;
562 int ret;
563
564 assert(op->length == stream_get_endp(op->s));
565 assert(msg->msg_iovlen == 2);
566
567 /* we can but try.
568 *
569 * SunOS, BSD and BSD derived kernels likely will clear ip_id, as
570 * well as the IP_MF flag, making this all quite pointless.
571 *
572 * However, for a system on which IP_MF is left alone, and ip_id left
573 * alone or else which sets same ip_id for each fragment this might
574 * work, eg linux.
575 *
576 * XXX-TODO: It would be much nicer to have the kernel's use their
577 * existing fragmentation support to do this for us. Bugs/RFEs need to
578 * be raised against the various kernels.
579 */
580
581 /* set More Frag */
582 iph->ip_off |= IP_MF;
583
584 /* ip frag offset is expressed in units of 8byte words */
585 offset = maxdatasize >> OSPF_WRITE_FRAG_SHIFT;
586
587 iovp = &msg->msg_iov[1];
588
589 while ((stream_get_endp(op->s) - stream_get_getp(op->s))
590 > maxdatasize) {
591 /* data length of this frag is to next offset value */
592 iovp->iov_len = offset << OSPF_WRITE_FRAG_SHIFT;
593 iph->ip_len = iovp->iov_len + sizeof(struct ip);
594 assert(iph->ip_len <= mtu);
595
596 sockopt_iphdrincl_swab_htosys(iph);
597
598 ret = sendmsg(fd, msg, flags);
599
600 sockopt_iphdrincl_swab_systoh(iph);
601
602 if (ret < 0)
603 flog_err(
604 EC_LIB_SOCKET,
605 "*** ospf_write_frags: sendmsg failed to %pI4, id %d, off %d, len %d, mtu %u failed with %s",
606 &iph->ip_dst, iph->ip_id, iph->ip_off,
607 iph->ip_len, mtu, safe_strerror(errno));
608
609 if (IS_DEBUG_OSPF_PACKET(type - 1, SEND)) {
610 zlog_debug(
611 "ospf_write_frags: sent id %d, off %d, len %d to %pI4",
612 iph->ip_id, iph->ip_off, iph->ip_len,
613 &iph->ip_dst);
614 }
615
616 iph->ip_off += offset;
617 stream_forward_getp(op->s, iovp->iov_len);
618 iovp->iov_base = stream_pnt(op->s);
619 }
620
621 /* setup for final fragment */
622 iovp->iov_len = stream_get_endp(op->s) - stream_get_getp(op->s);
623 iph->ip_len = iovp->iov_len + sizeof(struct ip);
624 iph->ip_off &= (~IP_MF);
625 }
626 #endif /* WANT_OSPF_WRITE_FRAGMENT */
627
628 static int ospf_write(struct thread *thread)
629 {
630 struct ospf *ospf = THREAD_ARG(thread);
631 struct ospf_interface *oi;
632 struct ospf_interface *last_serviced_oi = NULL;
633 struct ospf_packet *op;
634 struct sockaddr_in sa_dst;
635 struct ip iph;
636 struct msghdr msg;
637 struct iovec iov[2];
638 uint8_t type;
639 int ret;
640 int flags = 0;
641 struct listnode *node;
642 #ifdef WANT_OSPF_WRITE_FRAGMENT
643 static uint16_t ipid = 0;
644 uint16_t maxdatasize;
645 #endif /* WANT_OSPF_WRITE_FRAGMENT */
646 #define OSPF_WRITE_IPHL_SHIFT 2
647 int pkt_count = 0;
648
649 #ifdef GNU_LINUX
650 unsigned char cmsgbuf[64] = {};
651 struct cmsghdr *cm = (struct cmsghdr *)cmsgbuf;
652 struct in_pktinfo *pi;
653 #endif
654
655 if (ospf->fd < 0 || ospf->oi_running == 0) {
656 if (IS_DEBUG_OSPF_EVENT)
657 zlog_debug(
658 "ospf_write failed to send, fd %d, instance %u",
659 ospf->fd, ospf->oi_running);
660 return -1;
661 }
662
663 node = listhead(ospf->oi_write_q);
664 assert(node);
665 oi = listgetdata(node);
666
667 #ifdef WANT_OSPF_WRITE_FRAGMENT
668 /* seed ipid static with low order bits of time */
669 if (ipid == 0)
670 ipid = (time(NULL) & 0xffff);
671 #endif /* WANT_OSPF_WRITE_FRAGMENT */
672
673 while ((pkt_count < ospf->write_oi_count) && oi
674 && (last_serviced_oi != oi)) {
675 /* If there is only packet in the queue, the oi is removed from
676 write-q, so fix up the last interface that was serviced */
677 if (last_serviced_oi == NULL) {
678 last_serviced_oi = oi;
679 }
680 pkt_count++;
681 #ifdef WANT_OSPF_WRITE_FRAGMENT
682 /* convenience - max OSPF data per packet */
683 maxdatasize = oi->ifp->mtu - sizeof(struct ip);
684 #endif /* WANT_OSPF_WRITE_FRAGMENT */
685 /* Get one packet from queue. */
686 op = ospf_fifo_head(oi->obuf);
687 assert(op);
688 assert(op->length >= OSPF_HEADER_SIZE);
689
690 if (op->dst.s_addr == htonl(OSPF_ALLSPFROUTERS)
691 || op->dst.s_addr == htonl(OSPF_ALLDROUTERS))
692 ospf_if_ipmulticast(ospf, oi->address,
693 oi->ifp->ifindex);
694
695 /* Rewrite the md5 signature & update the seq */
696 ospf_make_md5_digest(oi, op);
697
698 /* Retrieve OSPF packet type. */
699 stream_set_getp(op->s, 1);
700 type = stream_getc(op->s);
701
702 /* reset get pointer */
703 stream_set_getp(op->s, 0);
704
705 memset(&iph, 0, sizeof(struct ip));
706 memset(&sa_dst, 0, sizeof(sa_dst));
707
708 sa_dst.sin_family = AF_INET;
709 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
710 sa_dst.sin_len = sizeof(sa_dst);
711 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
712 sa_dst.sin_addr = op->dst;
713 sa_dst.sin_port = htons(0);
714
715 /* Set DONTROUTE flag if dst is unicast. */
716 if (oi->type != OSPF_IFTYPE_VIRTUALLINK)
717 if (!IN_MULTICAST(htonl(op->dst.s_addr)))
718 flags = MSG_DONTROUTE;
719
720 iph.ip_hl = sizeof(struct ip) >> OSPF_WRITE_IPHL_SHIFT;
721 /* it'd be very strange for header to not be 4byte-word aligned
722 * but.. */
723 if (sizeof(struct ip)
724 > (unsigned int)(iph.ip_hl << OSPF_WRITE_IPHL_SHIFT))
725 iph.ip_hl++; /* we presume sizeof(struct ip) cant
726 overflow ip_hl.. */
727
728 iph.ip_v = IPVERSION;
729 iph.ip_tos = IPTOS_PREC_INTERNETCONTROL;
730 iph.ip_len = (iph.ip_hl << OSPF_WRITE_IPHL_SHIFT) + op->length;
731
732 #if defined(__DragonFly__)
733 /*
734 * DragonFly's raw socket expects ip_len/ip_off in network byte
735 * order.
736 */
737 iph.ip_len = htons(iph.ip_len);
738 #endif
739
740 #ifdef WANT_OSPF_WRITE_FRAGMENT
741 /* XXX-MT: not thread-safe at all..
742 * XXX: this presumes this is only programme sending OSPF
743 * packets
744 * otherwise, no guarantee ipid will be unique
745 */
746 iph.ip_id = ++ipid;
747 #endif /* WANT_OSPF_WRITE_FRAGMENT */
748
749 iph.ip_off = 0;
750 if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
751 iph.ip_ttl = OSPF_VL_IP_TTL;
752 else
753 iph.ip_ttl = OSPF_IP_TTL;
754 iph.ip_p = IPPROTO_OSPFIGP;
755 iph.ip_sum = 0;
756 iph.ip_src.s_addr = oi->address->u.prefix4.s_addr;
757 iph.ip_dst.s_addr = op->dst.s_addr;
758
759 memset(&msg, 0, sizeof(msg));
760 msg.msg_name = (caddr_t)&sa_dst;
761 msg.msg_namelen = sizeof(sa_dst);
762 msg.msg_iov = iov;
763 msg.msg_iovlen = 2;
764
765 iov[0].iov_base = (char *)&iph;
766 iov[0].iov_len = iph.ip_hl << OSPF_WRITE_IPHL_SHIFT;
767 iov[1].iov_base = stream_pnt(op->s);
768 iov[1].iov_len = op->length;
769
770 #ifdef GNU_LINUX
771 msg.msg_control = (caddr_t)cm;
772 cm->cmsg_level = SOL_IP;
773 cm->cmsg_type = IP_PKTINFO;
774 cm->cmsg_len = CMSG_LEN(sizeof(struct in_pktinfo));
775 pi = (struct in_pktinfo *)CMSG_DATA(cm);
776 pi->ipi_ifindex = oi->ifp->ifindex;
777
778 msg.msg_controllen = cm->cmsg_len;
779 #endif
780
781 /* Sadly we can not rely on kernels to fragment packets
782 * because of either IP_HDRINCL and/or multicast
783 * destination being set.
784 */
785
786 #ifdef WANT_OSPF_WRITE_FRAGMENT
787 if (op->length > maxdatasize)
788 ospf_write_frags(ospf->fd, op, &iph, &msg, maxdatasize,
789 oi->ifp->mtu, flags, type);
790 #endif /* WANT_OSPF_WRITE_FRAGMENT */
791
792 /* send final fragment (could be first) */
793 sockopt_iphdrincl_swab_htosys(&iph);
794 ret = sendmsg(ospf->fd, &msg, flags);
795 sockopt_iphdrincl_swab_systoh(&iph);
796 if (IS_DEBUG_OSPF_EVENT)
797 zlog_debug(
798 "ospf_write to %pI4, id %d, off %d, len %d, interface %s, mtu %u:",
799 &iph.ip_dst, iph.ip_id, iph.ip_off,
800 iph.ip_len, oi->ifp->name, oi->ifp->mtu);
801
802 /* sendmsg will return EPERM if firewall is blocking sending.
803 * This is a normal situation when 'ip nhrp map multicast xxx'
804 * is being used to send multicast packets to DMVPN peers. In
805 * that case the original message is blocked with iptables rule
806 * causing the EPERM result
807 */
808 if (ret < 0 && errno != EPERM)
809 flog_err(
810 EC_LIB_SOCKET,
811 "*** sendmsg in ospf_write failed to %pI4, id %d, off %d, len %d, interface %s, mtu %u: %s",
812 &iph.ip_dst, iph.ip_id, iph.ip_off,
813 iph.ip_len, oi->ifp->name, oi->ifp->mtu,
814 safe_strerror(errno));
815
816 /* Show debug sending packet. */
817 if (IS_DEBUG_OSPF_PACKET(type - 1, SEND)) {
818 if (IS_DEBUG_OSPF_PACKET(type - 1, DETAIL)) {
819 zlog_debug(
820 "-----------------------------------------------------");
821 stream_set_getp(op->s, 0);
822 ospf_packet_dump(op->s);
823 }
824
825 zlog_debug("%s sent to [%pI4] via [%s].",
826 lookup_msg(ospf_packet_type_str, type, NULL),
827 &op->dst, IF_NAME(oi));
828
829 if (IS_DEBUG_OSPF_PACKET(type - 1, DETAIL))
830 zlog_debug(
831 "-----------------------------------------------------");
832 }
833
834 switch (type) {
835 case OSPF_MSG_HELLO:
836 oi->hello_out++;
837 break;
838 case OSPF_MSG_DB_DESC:
839 oi->db_desc_out++;
840 break;
841 case OSPF_MSG_LS_REQ:
842 oi->ls_req_out++;
843 break;
844 case OSPF_MSG_LS_UPD:
845 oi->ls_upd_out++;
846 break;
847 case OSPF_MSG_LS_ACK:
848 oi->ls_ack_out++;
849 break;
850 default:
851 break;
852 }
853
854 /* Now delete packet from queue. */
855 ospf_packet_delete(oi);
856
857 /* Move this interface to the tail of write_q to
858 serve everyone in a round robin fashion */
859 list_delete_node(ospf->oi_write_q, node);
860 if (ospf_fifo_head(oi->obuf) == NULL) {
861 oi->on_write_q = 0;
862 last_serviced_oi = NULL;
863 oi = NULL;
864 } else {
865 listnode_add(ospf->oi_write_q, oi);
866 }
867
868 /* Setup to service from the head of the queue again */
869 if (!list_isempty(ospf->oi_write_q)) {
870 node = listhead(ospf->oi_write_q);
871 oi = listgetdata(node);
872 }
873 }
874
875 /* If packets still remain in queue, call write thread. */
876 if (!list_isempty(ospf->oi_write_q))
877 thread_add_write(master, ospf_write, ospf, ospf->fd,
878 &ospf->t_write);
879
880 return 0;
881 }
882
883 /* OSPF Hello message read -- RFC2328 Section 10.5. */
884 static void ospf_hello(struct ip *iph, struct ospf_header *ospfh,
885 struct stream *s, struct ospf_interface *oi, int size)
886 {
887 struct ospf_hello *hello;
888 struct ospf_neighbor *nbr;
889 int old_state;
890 struct prefix p;
891
892 /* increment statistics. */
893 oi->hello_in++;
894
895 hello = (struct ospf_hello *)stream_pnt(s);
896
897 /* If Hello is myself, silently discard. */
898 if (IPV4_ADDR_SAME(&ospfh->router_id, &oi->ospf->router_id)) {
899 if (IS_DEBUG_OSPF_PACKET(ospfh->type - 1, RECV)) {
900 zlog_debug(
901 "ospf_header[%s/%pI4]: selforiginated, dropping.",
902 lookup_msg(ospf_packet_type_str, ospfh->type,
903 NULL),
904 &iph->ip_src);
905 }
906 return;
907 }
908
909 /* get neighbor prefix. */
910 p.family = AF_INET;
911 p.prefixlen = ip_masklen(hello->network_mask);
912 p.u.prefix4 = iph->ip_src;
913
914 /* Compare network mask. */
915 /* Checking is ignored for Point-to-Point and Virtual link. */
916 /* Checking is also ignored for Point-to-Multipoint with /32 prefix */
917 if (oi->type != OSPF_IFTYPE_POINTOPOINT
918 && oi->type != OSPF_IFTYPE_VIRTUALLINK
919 && !(oi->type == OSPF_IFTYPE_POINTOMULTIPOINT
920 && oi->address->prefixlen == IPV4_MAX_BITLEN))
921 if (oi->address->prefixlen != p.prefixlen) {
922 flog_warn(
923 EC_OSPF_PACKET,
924 "Packet %pI4 [Hello:RECV]: NetworkMask mismatch on %s (configured prefix length is %d, but hello packet indicates %d).",
925 &ospfh->router_id, IF_NAME(oi),
926 (int)oi->address->prefixlen, (int)p.prefixlen);
927 return;
928 }
929
930 /* Compare Router Dead Interval. */
931 if (OSPF_IF_PARAM(oi, v_wait) != ntohl(hello->dead_interval)) {
932 flog_warn(EC_OSPF_PACKET,
933 "Packet %pI4 [Hello:RECV]: RouterDeadInterval mismatch (expected %u, but received %u).",
934 &ospfh->router_id,
935 OSPF_IF_PARAM(oi, v_wait),
936 ntohl(hello->dead_interval));
937 return;
938 }
939
940 /* Compare Hello Interval - ignored if fast-hellos are set. */
941 if (OSPF_IF_PARAM(oi, fast_hello) == 0) {
942 if (OSPF_IF_PARAM(oi, v_hello)
943 != ntohs(hello->hello_interval)) {
944 flog_warn(
945 EC_OSPF_PACKET,
946 "Packet %pI4 [Hello:RECV]: HelloInterval mismatch (expected %u, but received %u).",
947 &ospfh->router_id,
948 OSPF_IF_PARAM(oi, v_hello),
949 ntohs(hello->hello_interval));
950 return;
951 }
952 }
953
954 if (IS_DEBUG_OSPF_EVENT)
955 zlog_debug("Packet %pI4 [Hello:RECV]: Options %s vrf %s",
956 &ospfh->router_id,
957 ospf_options_dump(hello->options),
958 ospf_vrf_id_to_name(oi->ospf->vrf_id));
959
960 /* Compare options. */
961 #define REJECT_IF_TBIT_ON 1 /* XXX */
962 #ifdef REJECT_IF_TBIT_ON
963 if (CHECK_FLAG(hello->options, OSPF_OPTION_MT)) {
964 /*
965 * This router does not support non-zero TOS.
966 * Drop this Hello packet not to establish neighbor
967 * relationship.
968 */
969 flog_warn(EC_OSPF_PACKET,
970 "Packet %pI4 [Hello:RECV]: T-bit on, drop it.",
971 &ospfh->router_id);
972 return;
973 }
974 #endif /* REJECT_IF_TBIT_ON */
975
976 if (CHECK_FLAG(oi->ospf->config, OSPF_OPAQUE_CAPABLE)
977 && CHECK_FLAG(hello->options, OSPF_OPTION_O)) {
978 /*
979 * This router does know the correct usage of O-bit
980 * the bit should be set in DD packet only.
981 */
982 flog_warn(EC_OSPF_PACKET,
983 "Packet %pI4 [Hello:RECV]: O-bit abuse?",
984 &ospfh->router_id);
985 #ifdef STRICT_OBIT_USAGE_CHECK
986 return; /* Reject this packet. */
987 #else /* STRICT_OBIT_USAGE_CHECK */
988 UNSET_FLAG(hello->options, OSPF_OPTION_O); /* Ignore O-bit. */
989 #endif /* STRICT_OBIT_USAGE_CHECK */
990 }
991
992 /* new for NSSA is to ensure that NP is on and E is off */
993
994 if (oi->area->external_routing == OSPF_AREA_NSSA) {
995 if (!(CHECK_FLAG(OPTIONS(oi), OSPF_OPTION_NP)
996 && CHECK_FLAG(hello->options, OSPF_OPTION_NP)
997 && !CHECK_FLAG(OPTIONS(oi), OSPF_OPTION_E)
998 && !CHECK_FLAG(hello->options, OSPF_OPTION_E))) {
999 flog_warn(
1000 EC_OSPF_PACKET,
1001 "NSSA-Packet-%pI4[Hello:RECV]: my options: %x, his options %x",
1002 &ospfh->router_id, OPTIONS(oi),
1003 hello->options);
1004 return;
1005 }
1006 if (IS_DEBUG_OSPF_NSSA)
1007 zlog_debug("NSSA-Hello:RECV:Packet from %pI4:",
1008 &ospfh->router_id);
1009 } else
1010 /* The setting of the E-bit found in the Hello Packet's Options
1011 field must match this area's ExternalRoutingCapability A
1012 mismatch causes processing to stop and the packet to be
1013 dropped. The setting of the rest of the bits in the Hello
1014 Packet's Options field should be ignored. */
1015 if (CHECK_FLAG(OPTIONS(oi), OSPF_OPTION_E)
1016 != CHECK_FLAG(hello->options, OSPF_OPTION_E)) {
1017 flog_warn(
1018 EC_OSPF_PACKET,
1019 "Packet %pI4 [Hello:RECV]: my options: %x, his options %x",
1020 &ospfh->router_id, OPTIONS(oi),
1021 hello->options);
1022 return;
1023 }
1024
1025 /* get neighbour struct */
1026 nbr = ospf_nbr_get(oi, ospfh, iph, &p);
1027
1028 /* neighbour must be valid, ospf_nbr_get creates if none existed */
1029 assert(nbr);
1030
1031 old_state = nbr->state;
1032
1033 /* Add event to thread. */
1034 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_PacketReceived);
1035
1036 /* RFC2328 Section 9.5.1
1037 If the router is not eligible to become Designated Router,
1038 (snip) It must also send an Hello Packet in reply to an
1039 Hello Packet received from any eligible neighbor (other than
1040 the current Designated Router and Backup Designated Router). */
1041 if (oi->type == OSPF_IFTYPE_NBMA)
1042 if (PRIORITY(oi) == 0 && hello->priority > 0
1043 && IPV4_ADDR_CMP(&DR(oi), &iph->ip_src)
1044 && IPV4_ADDR_CMP(&BDR(oi), &iph->ip_src))
1045 OSPF_NSM_TIMER_ON(nbr->t_hello_reply,
1046 ospf_hello_reply_timer,
1047 OSPF_HELLO_REPLY_DELAY);
1048
1049 /* on NBMA network type, it happens to receive bidirectional Hello
1050 packet
1051 without advance 1-Way Received event.
1052 To avoid incorrect DR-seletion, raise 1-Way Received event.*/
1053 if (oi->type == OSPF_IFTYPE_NBMA
1054 && (old_state == NSM_Down || old_state == NSM_Attempt)) {
1055 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_OneWayReceived);
1056 nbr->priority = hello->priority;
1057 nbr->d_router = hello->d_router;
1058 nbr->bd_router = hello->bd_router;
1059 return;
1060 }
1061
1062 if (ospf_nbr_bidirectional(&oi->ospf->router_id, hello->neighbors,
1063 size - OSPF_HELLO_MIN_SIZE)) {
1064 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_TwoWayReceived);
1065 nbr->options |= hello->options;
1066 } else {
1067 /* If the router is DR_OTHER, RESTARTER will not wait
1068 * until it receives the hello from it if it receives
1069 * from DR and BDR.
1070 * So, helper might receives ONW_WAY hello from
1071 * RESTARTER. So not allowing to change the state if it
1072 * receives one_way hellow when it acts as HELPER for
1073 * that specific neighbor.
1074 */
1075 if (!OSPF_GR_IS_ACTIVE_HELPER(nbr))
1076 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_OneWayReceived);
1077 /* Set neighbor information. */
1078 nbr->priority = hello->priority;
1079 nbr->d_router = hello->d_router;
1080 nbr->bd_router = hello->bd_router;
1081 return;
1082 }
1083
1084 /* If neighbor itself declares DR and no BDR exists,
1085 cause event BackupSeen */
1086 if (IPV4_ADDR_SAME(&nbr->address.u.prefix4, &hello->d_router))
1087 if (hello->bd_router.s_addr == INADDR_ANY
1088 && oi->state == ISM_Waiting)
1089 OSPF_ISM_EVENT_SCHEDULE(oi, ISM_BackupSeen);
1090
1091 /* neighbor itself declares BDR. */
1092 if (oi->state == ISM_Waiting
1093 && IPV4_ADDR_SAME(&nbr->address.u.prefix4, &hello->bd_router))
1094 OSPF_ISM_EVENT_SCHEDULE(oi, ISM_BackupSeen);
1095
1096 /* had not previously. */
1097 if ((IPV4_ADDR_SAME(&nbr->address.u.prefix4, &hello->d_router)
1098 && IPV4_ADDR_CMP(&nbr->address.u.prefix4, &nbr->d_router))
1099 || (IPV4_ADDR_CMP(&nbr->address.u.prefix4, &hello->d_router)
1100 && IPV4_ADDR_SAME(&nbr->address.u.prefix4, &nbr->d_router)))
1101 OSPF_ISM_EVENT_SCHEDULE(oi, ISM_NeighborChange);
1102
1103 /* had not previously. */
1104 if ((IPV4_ADDR_SAME(&nbr->address.u.prefix4, &hello->bd_router)
1105 && IPV4_ADDR_CMP(&nbr->address.u.prefix4, &nbr->bd_router))
1106 || (IPV4_ADDR_CMP(&nbr->address.u.prefix4, &hello->bd_router)
1107 && IPV4_ADDR_SAME(&nbr->address.u.prefix4, &nbr->bd_router)))
1108 OSPF_ISM_EVENT_SCHEDULE(oi, ISM_NeighborChange);
1109
1110 /* Neighbor priority check. */
1111 if (nbr->priority >= 0 && nbr->priority != hello->priority)
1112 OSPF_ISM_EVENT_SCHEDULE(oi, ISM_NeighborChange);
1113
1114 /* Set neighbor information. */
1115 nbr->priority = hello->priority;
1116 nbr->d_router = hello->d_router;
1117 nbr->bd_router = hello->bd_router;
1118 }
1119
1120 /* Save DD flags/options/Seqnum received. */
1121 static void ospf_db_desc_save_current(struct ospf_neighbor *nbr,
1122 struct ospf_db_desc *dd)
1123 {
1124 nbr->last_recv.flags = dd->flags;
1125 nbr->last_recv.options = dd->options;
1126 nbr->last_recv.dd_seqnum = ntohl(dd->dd_seqnum);
1127 }
1128
1129 /* Process rest of DD packet. */
1130 static void ospf_db_desc_proc(struct stream *s, struct ospf_interface *oi,
1131 struct ospf_neighbor *nbr,
1132 struct ospf_db_desc *dd, uint16_t size)
1133 {
1134 struct ospf_lsa *new, *find;
1135 struct lsa_header *lsah;
1136
1137 stream_forward_getp(s, OSPF_DB_DESC_MIN_SIZE);
1138 for (size -= OSPF_DB_DESC_MIN_SIZE; size >= OSPF_LSA_HEADER_SIZE;
1139 size -= OSPF_LSA_HEADER_SIZE) {
1140 lsah = (struct lsa_header *)stream_pnt(s);
1141 stream_forward_getp(s, OSPF_LSA_HEADER_SIZE);
1142
1143 /* Unknown LS type. */
1144 if (lsah->type < OSPF_MIN_LSA || lsah->type >= OSPF_MAX_LSA) {
1145 flog_warn(EC_OSPF_PACKET,
1146 "Packet [DD:RECV]: Unknown LS type %d.",
1147 lsah->type);
1148 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_SeqNumberMismatch);
1149 return;
1150 }
1151
1152 if (IS_OPAQUE_LSA(lsah->type)
1153 && !CHECK_FLAG(nbr->options, OSPF_OPTION_O)) {
1154 flog_warn(EC_OSPF_PACKET,
1155 "LSA[Type%d:%pI4]: Opaque capability mismatch?",
1156 lsah->type, &lsah->id);
1157 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_SeqNumberMismatch);
1158 return;
1159 }
1160
1161 switch (lsah->type) {
1162 case OSPF_AS_EXTERNAL_LSA:
1163 case OSPF_OPAQUE_AS_LSA:
1164 /* Check for stub area. Reject if AS-External from stub
1165 but
1166 allow if from NSSA. */
1167 if (oi->area->external_routing == OSPF_AREA_STUB) {
1168 flog_warn(
1169 EC_OSPF_PACKET,
1170 "Packet [DD:RECV]: LSA[Type%d:%pI4] from %s area.",
1171 lsah->type, &lsah->id,
1172 (oi->area->external_routing
1173 == OSPF_AREA_STUB)
1174 ? "STUB"
1175 : "NSSA");
1176 OSPF_NSM_EVENT_SCHEDULE(nbr,
1177 NSM_SeqNumberMismatch);
1178 return;
1179 }
1180 break;
1181 default:
1182 break;
1183 }
1184
1185 /* Create LS-request object. */
1186 new = ospf_ls_request_new(lsah);
1187
1188 /* Lookup received LSA, then add LS request list. */
1189 find = ospf_lsa_lookup_by_header(oi->area, lsah);
1190
1191 /* ospf_lsa_more_recent is fine with NULL pointers */
1192 switch (ospf_lsa_more_recent(find, new)) {
1193 case -1:
1194 /* Neighbour has a more recent LSA, we must request it
1195 */
1196 ospf_ls_request_add(nbr, new);
1197 /* fallthru */
1198 case 0:
1199 /* If we have a copy of this LSA, it's either less
1200 * recent
1201 * and we're requesting it from neighbour (the case
1202 * above), or
1203 * it's as recent and we both have same copy (this
1204 * case).
1205 *
1206 * In neither of these two cases is there any point in
1207 * describing our copy of the LSA to the neighbour in a
1208 * DB-Summary packet, if we're still intending to do so.
1209 *
1210 * See: draft-ogier-ospf-dbex-opt-00.txt, describing the
1211 * backward compatible optimisation to OSPF DB Exchange
1212 * /
1213 * DB Description process implemented here.
1214 */
1215 if (find)
1216 ospf_lsdb_delete(&nbr->db_sum, find);
1217 ospf_lsa_discard(new);
1218 break;
1219 default:
1220 /* We have the more recent copy, nothing specific to do:
1221 * - no need to request neighbours stale copy
1222 * - must leave DB summary list copy alone
1223 */
1224 if (IS_DEBUG_OSPF_EVENT)
1225 zlog_debug(
1226 "Packet [DD:RECV]: LSA received Type %d, ID %pI4 is not recent.",
1227 lsah->type, &lsah->id);
1228 ospf_lsa_discard(new);
1229 }
1230 }
1231
1232 /* Master */
1233 if (IS_SET_DD_MS(nbr->dd_flags)) {
1234 nbr->dd_seqnum++;
1235
1236 /* Both sides have no More, then we're done with Exchange */
1237 if (!IS_SET_DD_M(dd->flags) && !IS_SET_DD_M(nbr->dd_flags))
1238 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_ExchangeDone);
1239 else
1240 ospf_db_desc_send(nbr);
1241 }
1242 /* Slave */
1243 else {
1244 nbr->dd_seqnum = ntohl(dd->dd_seqnum);
1245
1246 /* Send DD packet in reply.
1247 *
1248 * Must be done to acknowledge the Master's DD, regardless of
1249 * whether we have more LSAs ourselves to describe.
1250 *
1251 * This function will clear the 'More' bit, if after this DD
1252 * we have no more LSAs to describe to the master..
1253 */
1254 ospf_db_desc_send(nbr);
1255
1256 /* Slave can raise ExchangeDone now, if master is also done */
1257 if (!IS_SET_DD_M(dd->flags) && !IS_SET_DD_M(nbr->dd_flags))
1258 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_ExchangeDone);
1259 }
1260
1261 /* Save received neighbor values from DD. */
1262 ospf_db_desc_save_current(nbr, dd);
1263
1264 if (!nbr->t_ls_req)
1265 ospf_ls_req_send(nbr);
1266 }
1267
1268 static int ospf_db_desc_is_dup(struct ospf_db_desc *dd,
1269 struct ospf_neighbor *nbr)
1270 {
1271 /* Is DD duplicated? */
1272 if (dd->options == nbr->last_recv.options
1273 && dd->flags == nbr->last_recv.flags
1274 && dd->dd_seqnum == htonl(nbr->last_recv.dd_seqnum))
1275 return 1;
1276
1277 return 0;
1278 }
1279
1280 /* OSPF Database Description message read -- RFC2328 Section 10.6. */
1281 static void ospf_db_desc(struct ip *iph, struct ospf_header *ospfh,
1282 struct stream *s, struct ospf_interface *oi,
1283 uint16_t size)
1284 {
1285 struct ospf_db_desc *dd;
1286 struct ospf_neighbor *nbr;
1287
1288 /* Increment statistics. */
1289 oi->db_desc_in++;
1290
1291 dd = (struct ospf_db_desc *)stream_pnt(s);
1292
1293 nbr = ospf_nbr_lookup(oi, iph, ospfh);
1294 if (nbr == NULL) {
1295 flog_warn(EC_OSPF_PACKET, "Packet[DD]: Unknown Neighbor %pI4",
1296 &ospfh->router_id);
1297 return;
1298 }
1299
1300 /* Check MTU. */
1301 if ((OSPF_IF_PARAM(oi, mtu_ignore) == 0)
1302 && (ntohs(dd->mtu) > oi->ifp->mtu)) {
1303 flog_warn(
1304 EC_OSPF_PACKET,
1305 "Packet[DD]: Neighbor %pI4 MTU %u is larger than [%s]'s MTU %u",
1306 &nbr->router_id, ntohs(dd->mtu), IF_NAME(oi),
1307 oi->ifp->mtu);
1308 return;
1309 }
1310
1311 /*
1312 * XXX HACK by Hasso Tepper. Setting N/P bit in NSSA area DD packets is
1313 * not
1314 * required. In fact at least JunOS sends DD packets with P bit clear.
1315 * Until proper solution is developped, this hack should help.
1316 *
1317 * Update: According to the RFCs, N bit is specified /only/ for Hello
1318 * options, unfortunately its use in DD options is not specified. Hence
1319 * some
1320 * implementations follow E-bit semantics and set it in DD options, and
1321 * some
1322 * treat it as unspecified and hence follow the directive "default for
1323 * options is clear", ie unset.
1324 *
1325 * Reset the flag, as ospfd follows E-bit semantics.
1326 */
1327 if ((oi->area->external_routing == OSPF_AREA_NSSA)
1328 && (CHECK_FLAG(nbr->options, OSPF_OPTION_NP))
1329 && (!CHECK_FLAG(dd->options, OSPF_OPTION_NP))) {
1330 if (IS_DEBUG_OSPF_EVENT)
1331 zlog_debug(
1332 "Packet[DD]: Neighbour %pI4: Has NSSA capability, sends with N bit clear in DD options",
1333 &nbr->router_id);
1334 SET_FLAG(dd->options, OSPF_OPTION_NP);
1335 }
1336
1337 #ifdef REJECT_IF_TBIT_ON
1338 if (CHECK_FLAG(dd->options, OSPF_OPTION_MT)) {
1339 /*
1340 * In Hello protocol, optional capability must have checked
1341 * to prevent this T-bit enabled router be my neighbor.
1342 */
1343 flog_warn(EC_OSPF_PACKET, "Packet[DD]: Neighbor %pI4: T-bit on?",
1344 &nbr->router_id);
1345 return;
1346 }
1347 #endif /* REJECT_IF_TBIT_ON */
1348
1349 if (CHECK_FLAG(dd->options, OSPF_OPTION_O)
1350 && !CHECK_FLAG(oi->ospf->config, OSPF_OPAQUE_CAPABLE)) {
1351 /*
1352 * This node is not configured to handle O-bit, for now.
1353 * Clear it to ignore unsupported capability proposed by
1354 * neighbor.
1355 */
1356 UNSET_FLAG(dd->options, OSPF_OPTION_O);
1357 }
1358
1359 /* Add event to thread. */
1360 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_PacketReceived);
1361
1362 if (CHECK_FLAG(oi->ospf->config, OSPF_LOG_ADJACENCY_DETAIL))
1363 zlog_info(
1364 "%s:Packet[DD]: Neighbor %pI4 state is %s, seq_num:0x%x, local:0x%x",
1365 (oi->ospf->name) ? oi->ospf->name : VRF_DEFAULT_NAME,
1366 &nbr->router_id,
1367 lookup_msg(ospf_nsm_state_msg, nbr->state, NULL),
1368 ntohl(dd->dd_seqnum), nbr->dd_seqnum);
1369
1370 /* Process DD packet by neighbor status. */
1371 switch (nbr->state) {
1372 case NSM_Down:
1373 case NSM_Attempt:
1374 case NSM_TwoWay:
1375 if (CHECK_FLAG(oi->ospf->config, OSPF_LOG_ADJACENCY_DETAIL))
1376 zlog_info(
1377 "Packet[DD]: Neighbor %pI4 state is %s, packet discarded.",
1378 &nbr->router_id,
1379 lookup_msg(ospf_nsm_state_msg, nbr->state,
1380 NULL));
1381 break;
1382 case NSM_Init:
1383 OSPF_NSM_EVENT_EXECUTE(nbr, NSM_TwoWayReceived);
1384 /* If the new state is ExStart, the processing of the current
1385 packet should then continue in this new state by falling
1386 through to case ExStart below. */
1387 if (nbr->state != NSM_ExStart)
1388 break;
1389 /* fallthru */
1390 case NSM_ExStart:
1391 /* Initial DBD */
1392 if ((IS_SET_DD_ALL(dd->flags) == OSPF_DD_FLAG_ALL)
1393 && (size == OSPF_DB_DESC_MIN_SIZE)) {
1394 if (IPV4_ADDR_CMP(&nbr->router_id, &oi->ospf->router_id)
1395 > 0) {
1396 /* We're Slave---obey */
1397 if (CHECK_FLAG(oi->ospf->config,
1398 OSPF_LOG_ADJACENCY_DETAIL))
1399 zlog_info(
1400 "Packet[DD]: Neighbor %pI4 Negotiation done (Slave).",
1401 &nbr->router_id);
1402
1403 nbr->dd_seqnum = ntohl(dd->dd_seqnum);
1404
1405 /* Reset I/MS */
1406 UNSET_FLAG(nbr->dd_flags,
1407 (OSPF_DD_FLAG_MS | OSPF_DD_FLAG_I));
1408 } else {
1409 /* We're Master, ignore the initial DBD from
1410 * Slave */
1411 if (CHECK_FLAG(oi->ospf->config,
1412 OSPF_LOG_ADJACENCY_DETAIL))
1413 zlog_info(
1414 "Packet[DD]: Neighbor %pI4: Initial DBD from Slave, ignoring.",
1415 &nbr->router_id);
1416 break;
1417 }
1418 }
1419 /* Ack from the Slave */
1420 else if (!IS_SET_DD_MS(dd->flags) && !IS_SET_DD_I(dd->flags)
1421 && ntohl(dd->dd_seqnum) == nbr->dd_seqnum
1422 && IPV4_ADDR_CMP(&nbr->router_id, &oi->ospf->router_id)
1423 < 0) {
1424 zlog_info(
1425 "Packet[DD]: Neighbor %pI4 Negotiation done (Master).",
1426 &nbr->router_id);
1427 /* Reset I, leaving MS */
1428 UNSET_FLAG(nbr->dd_flags, OSPF_DD_FLAG_I);
1429 } else {
1430 flog_warn(EC_OSPF_PACKET,
1431 "Packet[DD]: Neighbor %pI4 Negotiation fails.",
1432 &nbr->router_id);
1433 break;
1434 }
1435
1436 /* This is where the real Options are saved */
1437 nbr->options = dd->options;
1438
1439 if (CHECK_FLAG(oi->ospf->config, OSPF_OPAQUE_CAPABLE)) {
1440 if (IS_DEBUG_OSPF_EVENT)
1441 zlog_debug(
1442 "Neighbor[%pI4] is %sOpaque-capable.",
1443 &nbr->router_id,
1444 CHECK_FLAG(nbr->options, OSPF_OPTION_O)
1445 ? ""
1446 : "NOT ");
1447
1448 if (!CHECK_FLAG(nbr->options, OSPF_OPTION_O)
1449 && IPV4_ADDR_SAME(&DR(oi),
1450 &nbr->address.u.prefix4)) {
1451 flog_warn(
1452 EC_OSPF_PACKET,
1453 "DR-neighbor[%pI4] is NOT opaque-capable; Opaque-LSAs cannot be reliably advertised in this network.",
1454 &nbr->router_id);
1455 /* This situation is undesirable, but not a real
1456 * error. */
1457 }
1458 }
1459
1460 OSPF_NSM_EVENT_EXECUTE(nbr, NSM_NegotiationDone);
1461
1462 /* continue processing rest of packet. */
1463 ospf_db_desc_proc(s, oi, nbr, dd, size);
1464 break;
1465 case NSM_Exchange:
1466 if (ospf_db_desc_is_dup(dd, nbr)) {
1467 if (IS_SET_DD_MS(nbr->dd_flags))
1468 /* Master: discard duplicated DD packet. */
1469 zlog_info(
1470 "Packet[DD] (Master): Neighbor %pI4 packet duplicated.",
1471 &nbr->router_id);
1472 else
1473 /* Slave: cause to retransmit the last Database
1474 Description. */
1475 {
1476 zlog_info(
1477 "Packet[DD] [Slave]: Neighbor %pI4 packet duplicated.",
1478 &nbr->router_id);
1479 ospf_db_desc_resend(nbr);
1480 }
1481 break;
1482 }
1483
1484 /* Otherwise DD packet should be checked. */
1485 /* Check Master/Slave bit mismatch */
1486 if (IS_SET_DD_MS(dd->flags)
1487 != IS_SET_DD_MS(nbr->last_recv.flags)) {
1488 flog_warn(EC_OSPF_PACKET,
1489 "Packet[DD]: Neighbor %pI4 MS-bit mismatch.",
1490 &nbr->router_id);
1491 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_SeqNumberMismatch);
1492 if (IS_DEBUG_OSPF_EVENT)
1493 zlog_debug(
1494 "Packet[DD]: dd->flags=%d, nbr->dd_flags=%d",
1495 dd->flags, nbr->dd_flags);
1496 break;
1497 }
1498
1499 /* Check initialize bit is set. */
1500 if (IS_SET_DD_I(dd->flags)) {
1501 zlog_info("Packet[DD]: Neighbor %pI4 I-bit set.",
1502 &nbr->router_id);
1503 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_SeqNumberMismatch);
1504 break;
1505 }
1506
1507 /* Check DD Options. */
1508 if (dd->options != nbr->options) {
1509 flog_warn(EC_OSPF_PACKET,
1510 "Packet[DD]: Neighbor %pI4 options mismatch.",
1511 &nbr->router_id);
1512 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_SeqNumberMismatch);
1513 break;
1514 }
1515
1516 /* Check DD sequence number. */
1517 if ((IS_SET_DD_MS(nbr->dd_flags)
1518 && ntohl(dd->dd_seqnum) != nbr->dd_seqnum)
1519 || (!IS_SET_DD_MS(nbr->dd_flags)
1520 && ntohl(dd->dd_seqnum) != nbr->dd_seqnum + 1)) {
1521 flog_warn(
1522 EC_OSPF_PACKET,
1523 "Packet[DD]: Neighbor %pI4 sequence number mismatch.",
1524 &nbr->router_id);
1525 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_SeqNumberMismatch);
1526 break;
1527 }
1528
1529 /* Continue processing rest of packet. */
1530 ospf_db_desc_proc(s, oi, nbr, dd, size);
1531 break;
1532 case NSM_Loading:
1533 case NSM_Full:
1534 if (ospf_db_desc_is_dup(dd, nbr)) {
1535 if (IS_SET_DD_MS(nbr->dd_flags)) {
1536 /* Master should discard duplicate DD packet. */
1537 zlog_info(
1538 "Packet[DD]: Neighbor %pI4 duplicated, packet discarded.",
1539 &nbr->router_id);
1540 break;
1541 } else {
1542 if (monotime_since(&nbr->last_send_ts, NULL)
1543 < nbr->v_inactivity * 1000000LL) {
1544 /* In states Loading and Full the slave
1545 must resend
1546 its last Database Description packet
1547 in response to
1548 duplicate Database Description
1549 packets received
1550 from the master. For this reason the
1551 slave must
1552 wait RouterDeadInterval seconds
1553 before freeing the
1554 last Database Description packet.
1555 Reception of a
1556 Database Description packet from the
1557 master after
1558 this interval will generate a
1559 SeqNumberMismatch
1560 neighbor event. RFC2328 Section 10.8
1561 */
1562 ospf_db_desc_resend(nbr);
1563 break;
1564 }
1565 }
1566 }
1567
1568 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_SeqNumberMismatch);
1569 break;
1570 default:
1571 flog_warn(EC_OSPF_PACKET,
1572 "Packet[DD]: Neighbor %pI4 NSM illegal status %u.",
1573 &nbr->router_id, nbr->state);
1574 break;
1575 }
1576 }
1577
1578 #define OSPF_LSA_KEY_SIZE 12 /* type(4) + id(4) + ar(4) */
1579
1580 /* OSPF Link State Request Read -- RFC2328 Section 10.7. */
1581 static void ospf_ls_req(struct ip *iph, struct ospf_header *ospfh,
1582 struct stream *s, struct ospf_interface *oi,
1583 uint16_t size)
1584 {
1585 struct ospf_neighbor *nbr;
1586 uint32_t ls_type;
1587 struct in_addr ls_id;
1588 struct in_addr adv_router;
1589 struct ospf_lsa *find;
1590 struct list *ls_upd;
1591 unsigned int length;
1592
1593 /* Increment statistics. */
1594 oi->ls_req_in++;
1595
1596 nbr = ospf_nbr_lookup(oi, iph, ospfh);
1597 if (nbr == NULL) {
1598 flog_warn(EC_OSPF_PACKET,
1599 "Link State Request: Unknown Neighbor %pI4",
1600 &ospfh->router_id);
1601 return;
1602 }
1603
1604 /* Add event to thread. */
1605 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_PacketReceived);
1606
1607 /* Neighbor State should be Exchange or later. */
1608 if (nbr->state != NSM_Exchange && nbr->state != NSM_Loading
1609 && nbr->state != NSM_Full) {
1610 flog_warn(
1611 EC_OSPF_PACKET,
1612 "Link State Request received from %pI4: Neighbor state is %s, packet discarded.",
1613 &ospfh->router_id,
1614 lookup_msg(ospf_nsm_state_msg, nbr->state, NULL));
1615 return;
1616 }
1617
1618 /* Send Link State Update for ALL requested LSAs. */
1619 ls_upd = list_new();
1620 length = OSPF_HEADER_SIZE + OSPF_LS_UPD_MIN_SIZE;
1621
1622 while (size >= OSPF_LSA_KEY_SIZE) {
1623 /* Get one slice of Link State Request. */
1624 ls_type = stream_getl(s);
1625 ls_id.s_addr = stream_get_ipv4(s);
1626 adv_router.s_addr = stream_get_ipv4(s);
1627
1628 /* Verify LSA type. */
1629 if (ls_type < OSPF_MIN_LSA || ls_type >= OSPF_MAX_LSA) {
1630 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_BadLSReq);
1631 list_delete(&ls_upd);
1632 return;
1633 }
1634
1635 /* Search proper LSA in LSDB. */
1636 find = ospf_lsa_lookup(oi->ospf, oi->area, ls_type, ls_id,
1637 adv_router);
1638 if (find == NULL) {
1639 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_BadLSReq);
1640 list_delete(&ls_upd);
1641 return;
1642 }
1643
1644 /* Packet overflows MTU size, send immediately. */
1645 if (length + ntohs(find->data->length) > ospf_packet_max(oi)) {
1646 if (oi->type == OSPF_IFTYPE_NBMA)
1647 ospf_ls_upd_send(nbr, ls_upd,
1648 OSPF_SEND_PACKET_DIRECT, 0);
1649 else
1650 ospf_ls_upd_send(nbr, ls_upd,
1651 OSPF_SEND_PACKET_INDIRECT, 0);
1652
1653 /* Only remove list contents. Keep ls_upd. */
1654 list_delete_all_node(ls_upd);
1655
1656 length = OSPF_HEADER_SIZE + OSPF_LS_UPD_MIN_SIZE;
1657 }
1658
1659 /* Append LSA to update list. */
1660 listnode_add(ls_upd, find);
1661 length += ntohs(find->data->length);
1662
1663 size -= OSPF_LSA_KEY_SIZE;
1664 }
1665
1666 /* Send rest of Link State Update. */
1667 if (listcount(ls_upd) > 0) {
1668 if (oi->type == OSPF_IFTYPE_NBMA)
1669 ospf_ls_upd_send(nbr, ls_upd, OSPF_SEND_PACKET_DIRECT,
1670 0);
1671 else
1672 ospf_ls_upd_send(nbr, ls_upd, OSPF_SEND_PACKET_INDIRECT,
1673 0);
1674
1675 list_delete(&ls_upd);
1676 } else
1677 list_delete(&ls_upd);
1678 }
1679
1680 /* Get the list of LSAs from Link State Update packet.
1681 And process some validation -- RFC2328 Section 13. (1)-(2). */
1682 static struct list *ospf_ls_upd_list_lsa(struct ospf_neighbor *nbr,
1683 struct stream *s,
1684 struct ospf_interface *oi, size_t size)
1685 {
1686 uint16_t count, sum;
1687 uint32_t length;
1688 struct lsa_header *lsah;
1689 struct ospf_lsa *lsa;
1690 struct list *lsas;
1691
1692 lsas = list_new();
1693
1694 count = stream_getl(s);
1695 size -= OSPF_LS_UPD_MIN_SIZE; /* # LSAs */
1696
1697 for (; size >= OSPF_LSA_HEADER_SIZE && count > 0;
1698 size -= length, stream_forward_getp(s, length), count--) {
1699 lsah = (struct lsa_header *)stream_pnt(s);
1700 length = ntohs(lsah->length);
1701
1702 if (length > size) {
1703 flog_warn(
1704 EC_OSPF_PACKET,
1705 "Link State Update: LSA length exceeds packet size.");
1706 break;
1707 }
1708
1709 /* Validate the LSA's LS checksum. */
1710 sum = lsah->checksum;
1711 if (!ospf_lsa_checksum_valid(lsah)) {
1712 /* (bug #685) more details in a one-line message make it
1713 * possible
1714 * to identify problem source on the one hand and to
1715 * have a better
1716 * chance to compress repeated messages in syslog on the
1717 * other */
1718 flog_warn(
1719 EC_OSPF_PACKET,
1720 "Link State Update: LSA checksum error %x/%x, ID=%pI4 from: nbr %pI4, router ID %pI4, adv router %pI4",
1721 sum, lsah->checksum, &lsah->id,
1722 &nbr->src, &nbr->router_id,
1723 &lsah->adv_router);
1724 continue;
1725 }
1726
1727 /* Examine the LSA's LS type. */
1728 if (lsah->type < OSPF_MIN_LSA || lsah->type >= OSPF_MAX_LSA) {
1729 flog_warn(EC_OSPF_PACKET,
1730 "Link State Update: Unknown LS type %d",
1731 lsah->type);
1732 continue;
1733 }
1734
1735 /*
1736 * What if the received LSA's age is greater than MaxAge?
1737 * Treat it as a MaxAge case -- endo.
1738 */
1739 if (ntohs(lsah->ls_age) > OSPF_LSA_MAXAGE)
1740 lsah->ls_age = htons(OSPF_LSA_MAXAGE);
1741
1742 if (CHECK_FLAG(nbr->options, OSPF_OPTION_O)) {
1743 #ifdef STRICT_OBIT_USAGE_CHECK
1744 if ((IS_OPAQUE_LSA(lsah->type)
1745 && !CHECK_FLAG(lsah->options, OSPF_OPTION_O))
1746 || (!IS_OPAQUE_LSA(lsah->type)
1747 && CHECK_FLAG(lsah->options, OSPF_OPTION_O))) {
1748 /*
1749 * This neighbor must know the exact usage of
1750 * O-bit;
1751 * the bit will be set in Type-9,10,11 LSAs
1752 * only.
1753 */
1754 flog_warn(EC_OSPF_PACKET,
1755 "LSA[Type%d:%pI4]: O-bit abuse?",
1756 lsah->type, &lsah->id);
1757 continue;
1758 }
1759 #endif /* STRICT_OBIT_USAGE_CHECK */
1760
1761 /* Do not take in AS External Opaque-LSAs if we are a
1762 * stub. */
1763 if (lsah->type == OSPF_OPAQUE_AS_LSA
1764 && nbr->oi->area->external_routing
1765 != OSPF_AREA_DEFAULT) {
1766 if (IS_DEBUG_OSPF_EVENT)
1767 zlog_debug(
1768 "LSA[Type%d:%pI4]: We are a stub, don't take this LSA.",
1769 lsah->type,
1770 &lsah->id);
1771 continue;
1772 }
1773 } else if (IS_OPAQUE_LSA(lsah->type)) {
1774 flog_warn(EC_OSPF_PACKET,
1775 "LSA[Type%d:%pI4]: Opaque capability mismatch?",
1776 lsah->type, &lsah->id);
1777 continue;
1778 }
1779
1780 /* Create OSPF LSA instance. */
1781 lsa = ospf_lsa_new_and_data(length);
1782
1783 lsa->vrf_id = oi->ospf->vrf_id;
1784 /* We may wish to put some error checking if type NSSA comes in
1785 and area not in NSSA mode */
1786 switch (lsah->type) {
1787 case OSPF_AS_EXTERNAL_LSA:
1788 case OSPF_OPAQUE_AS_LSA:
1789 lsa->area = NULL;
1790 break;
1791 case OSPF_OPAQUE_LINK_LSA:
1792 lsa->oi = oi; /* Remember incoming interface for
1793 flooding control. */
1794 /* Fallthrough */
1795 default:
1796 lsa->area = oi->area;
1797 break;
1798 }
1799
1800 memcpy(lsa->data, lsah, length);
1801
1802 if (IS_DEBUG_OSPF_EVENT)
1803 zlog_debug(
1804 "LSA[Type%d:%pI4]: %p new LSA created with Link State Update",
1805 lsa->data->type, &lsa->data->id,
1806 (void *)lsa);
1807 listnode_add(lsas, lsa);
1808 }
1809
1810 return lsas;
1811 }
1812
1813 /* Cleanup Update list. */
1814 static void ospf_upd_list_clean(struct list *lsas)
1815 {
1816 struct listnode *node, *nnode;
1817 struct ospf_lsa *lsa;
1818
1819 for (ALL_LIST_ELEMENTS(lsas, node, nnode, lsa))
1820 ospf_lsa_discard(lsa);
1821
1822 list_delete(&lsas);
1823 }
1824
1825 /* OSPF Link State Update message read -- RFC2328 Section 13. */
1826 static void ospf_ls_upd(struct ospf *ospf, struct ip *iph,
1827 struct ospf_header *ospfh, struct stream *s,
1828 struct ospf_interface *oi, uint16_t size)
1829 {
1830 struct ospf_neighbor *nbr;
1831 struct list *lsas;
1832 struct listnode *node, *nnode;
1833 struct ospf_lsa *lsa = NULL;
1834 /* unsigned long ls_req_found = 0; */
1835
1836 /* Dis-assemble the stream, update each entry, re-encapsulate for
1837 * flooding */
1838
1839 /* Increment statistics. */
1840 oi->ls_upd_in++;
1841
1842 /* Check neighbor. */
1843 nbr = ospf_nbr_lookup(oi, iph, ospfh);
1844 if (nbr == NULL) {
1845 flog_warn(EC_OSPF_PACKET,
1846 "Link State Update: Unknown Neighbor %pI4 on int: %s",
1847 &ospfh->router_id, IF_NAME(oi));
1848 return;
1849 }
1850
1851 /* Add event to thread. */
1852 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_PacketReceived);
1853
1854 /* Check neighbor state. */
1855 if (nbr->state < NSM_Exchange) {
1856 if (IS_DEBUG_OSPF(nsm, NSM_EVENTS))
1857 zlog_debug(
1858 "Link State Update: Neighbor[%pI4] state %s is less than Exchange",
1859 &ospfh->router_id,
1860 lookup_msg(ospf_nsm_state_msg, nbr->state,
1861 NULL));
1862 return;
1863 }
1864
1865 /* Get list of LSAs from Link State Update packet. - Also performs
1866 * Stages 1 (validate LSA checksum) and 2 (check for LSA consistent
1867 * type) of section 13.
1868 */
1869 lsas = ospf_ls_upd_list_lsa(nbr, s, oi, size);
1870
1871 if (lsas == NULL)
1872 return;
1873 #define DISCARD_LSA(L, N) \
1874 { \
1875 if (IS_DEBUG_OSPF_EVENT) \
1876 zlog_debug( \
1877 "ospf_lsa_discard() in ospf_ls_upd() point %d: lsa %p" \
1878 " Type-%d", \
1879 N, (void *)lsa, (int)lsa->data->type); \
1880 ospf_lsa_discard(L); \
1881 continue; \
1882 }
1883
1884 /* Process each LSA received in the one packet.
1885 *
1886 * Numbers in parentheses, e.g. (1), (2), etc., and the corresponding
1887 * text below are from the steps in RFC 2328, Section 13.
1888 */
1889 for (ALL_LIST_ELEMENTS(lsas, node, nnode, lsa)) {
1890 struct ospf_lsa *ls_ret, *current;
1891 int ret = 1;
1892
1893 if (IS_DEBUG_OSPF(lsa, LSA))
1894 zlog_debug("LSA Type-%d from %pI4, ID: %pI4, ADV: %pI4",
1895 lsa->data->type, &ospfh->router_id,
1896 &lsa->data->id, &lsa->data->adv_router);
1897
1898 listnode_delete(lsas,
1899 lsa); /* We don't need it in list anymore */
1900
1901 /* (1) Validate Checksum - Done above by ospf_ls_upd_list_lsa()
1902 */
1903
1904 /* (2) LSA Type - Done above by ospf_ls_upd_list_lsa() */
1905
1906 /* (3) Do not take in AS External LSAs if we are a stub or NSSA.
1907 */
1908
1909 /* Do not take in AS NSSA if this neighbor and we are not NSSA
1910 */
1911
1912 /* Do take in Type-7's if we are an NSSA */
1913
1914 /* If we are also an ABR, later translate them to a Type-5
1915 * packet */
1916
1917 /* Later, an NSSA Re-fresh can Re-fresh Type-7's and an ABR will
1918 translate them to a separate Type-5 packet. */
1919
1920 if (lsa->data->type == OSPF_AS_EXTERNAL_LSA)
1921 /* Reject from STUB or NSSA */
1922 if (nbr->oi->area->external_routing
1923 != OSPF_AREA_DEFAULT) {
1924 if (IS_DEBUG_OSPF_NSSA)
1925 zlog_debug(
1926 "Incoming External LSA Discarded: We are NSSA/STUB Area");
1927 DISCARD_LSA(lsa, 1);
1928 }
1929
1930 if (lsa->data->type == OSPF_AS_NSSA_LSA)
1931 if (nbr->oi->area->external_routing != OSPF_AREA_NSSA) {
1932 if (IS_DEBUG_OSPF_NSSA)
1933 zlog_debug(
1934 "Incoming NSSA LSA Discarded: Not NSSA Area");
1935 DISCARD_LSA(lsa, 2);
1936 }
1937
1938 /* VU229804: Router-LSA Adv-ID must be equal to LS-ID */
1939 if (lsa->data->type == OSPF_ROUTER_LSA)
1940 if (!IPV4_ADDR_SAME(&lsa->data->id,
1941 &lsa->data->adv_router)) {
1942 flog_err(
1943 EC_OSPF_ROUTER_LSA_MISMATCH,
1944 "Incoming Router-LSA from %pI4 with Adv-ID[%pI4] != LS-ID[%pI4]",
1945 &ospfh->router_id, &lsa->data->id,
1946 &lsa->data->adv_router);
1947 flog_err(
1948 EC_OSPF_DOMAIN_CORRUPT,
1949 "OSPF domain compromised by attack or corruption. Verify correct operation of -ALL- OSPF routers.");
1950 DISCARD_LSA(lsa, 0);
1951 }
1952
1953 /* Find the LSA in the current database. */
1954
1955 current = ospf_lsa_lookup_by_header(oi->area, lsa->data);
1956
1957 /* (4) If the LSA's LS age is equal to MaxAge, and there is
1958 currently
1959 no instance of the LSA in the router's link state database,
1960 and none of router's neighbors are in states Exchange or
1961 Loading,
1962 then take the following actions: */
1963
1964 if (IS_LSA_MAXAGE(lsa) && !current
1965 && ospf_check_nbr_status(oi->ospf)) {
1966 /* (4a) Response Link State Acknowledgment. */
1967 ospf_ls_ack_send(nbr, lsa);
1968
1969 /* (4b) Discard LSA. */
1970 if (IS_DEBUG_OSPF(lsa, LSA)) {
1971 zlog_debug(
1972 "Link State Update[%s]: LS age is equal to MaxAge.",
1973 dump_lsa_key(lsa));
1974 }
1975 DISCARD_LSA(lsa, 3);
1976 }
1977
1978 if (IS_OPAQUE_LSA(lsa->data->type)
1979 && IPV4_ADDR_SAME(&lsa->data->adv_router,
1980 &oi->ospf->router_id)) {
1981 /*
1982 * Even if initial flushing seems to be completed, there
1983 * might
1984 * be a case that self-originated LSA with MaxAge still
1985 * remain
1986 * in the routing domain.
1987 * Just send an LSAck message to cease retransmission.
1988 */
1989 if (IS_LSA_MAXAGE(lsa)) {
1990 zlog_info("LSA[%s]: Boomerang effect?",
1991 dump_lsa_key(lsa));
1992 ospf_ls_ack_send(nbr, lsa);
1993 ospf_lsa_discard(lsa);
1994
1995 if (current != NULL && !IS_LSA_MAXAGE(current))
1996 ospf_opaque_lsa_refresh_schedule(
1997 current);
1998 continue;
1999 }
2000
2001 /*
2002 * If an instance of self-originated Opaque-LSA is not
2003 * found
2004 * in the LSDB, there are some possible cases here.
2005 *
2006 * 1) This node lost opaque-capability after restart.
2007 * 2) Else, a part of opaque-type is no more supported.
2008 * 3) Else, a part of opaque-id is no more supported.
2009 *
2010 * Anyway, it is still this node's responsibility to
2011 * flush it.
2012 * Otherwise, the LSA instance remains in the routing
2013 * domain
2014 * until its age reaches to MaxAge.
2015 */
2016 /* XXX: We should deal with this for *ALL* LSAs, not
2017 * just opaque */
2018 if (current == NULL) {
2019 if (IS_DEBUG_OSPF_EVENT)
2020 zlog_debug(
2021 "LSA[%s]: Previously originated Opaque-LSA,not found in the LSDB.",
2022 dump_lsa_key(lsa));
2023
2024 SET_FLAG(lsa->flags, OSPF_LSA_SELF);
2025
2026 ospf_ls_ack_send(nbr, lsa);
2027
2028 ospf_opaque_self_originated_lsa_received(nbr,
2029 lsa);
2030 continue;
2031 }
2032 }
2033
2034 /* It might be happen that received LSA is self-originated
2035 * network LSA, but
2036 * router ID is changed. So, we should check if LSA is a
2037 * network-LSA whose
2038 * Link State ID is one of the router's own IP interface
2039 * addresses but whose
2040 * Advertising Router is not equal to the router's own Router ID
2041 * According to RFC 2328 12.4.2 and 13.4 this LSA should be
2042 * flushed.
2043 */
2044
2045 if (lsa->data->type == OSPF_NETWORK_LSA) {
2046 struct listnode *oinode, *oinnode;
2047 struct ospf_interface *out_if;
2048 int Flag = 0;
2049
2050 for (ALL_LIST_ELEMENTS(oi->ospf->oiflist, oinode,
2051 oinnode, out_if)) {
2052 if (out_if == NULL)
2053 break;
2054
2055 if ((IPV4_ADDR_SAME(&out_if->address->u.prefix4,
2056 &lsa->data->id))
2057 && (!(IPV4_ADDR_SAME(
2058 &oi->ospf->router_id,
2059 &lsa->data->adv_router)))) {
2060 if (out_if->network_lsa_self) {
2061 ospf_lsa_flush_area(
2062 lsa, out_if->area);
2063 if (IS_DEBUG_OSPF_EVENT)
2064 zlog_debug(
2065 "ospf_lsa_discard() in ospf_ls_upd() point 9: lsa %p Type-%d",
2066 (void *)lsa,
2067 (int)lsa->data
2068 ->type);
2069 ospf_lsa_discard(lsa);
2070 Flag = 1;
2071 }
2072 break;
2073 }
2074 }
2075 if (Flag)
2076 continue;
2077 }
2078
2079 /* (5) Find the instance of this LSA that is currently contained
2080 in the router's link state database. If there is no
2081 database copy, or the received LSA is more recent than
2082 the database copy the following steps must be performed.
2083 (The sub steps from RFC 2328 section 13 step (5) will be
2084 performed in
2085 ospf_flood() ) */
2086
2087 if (current == NULL
2088 || (ret = ospf_lsa_more_recent(current, lsa)) < 0) {
2089 /* CVE-2017-3224 */
2090 if (current && (lsa->data->ls_seqnum ==
2091 htonl(OSPF_MAX_SEQUENCE_NUMBER)
2092 && !IS_LSA_MAXAGE(lsa))) {
2093 zlog_debug(
2094 "Link State Update[%s]: has Max Seq but not MaxAge. Dropping it",
2095 dump_lsa_key(lsa));
2096
2097 DISCARD_LSA(lsa, 4);
2098 }
2099
2100 /* Actual flooding procedure. */
2101 if (ospf_flood(oi->ospf, nbr, current, lsa)
2102 < 0) /* Trap NSSA later. */
2103 DISCARD_LSA(lsa, 5);
2104 continue;
2105 }
2106
2107 /* (6) Else, If there is an instance of the LSA on the sending
2108 neighbor's Link state request list, an error has occurred in
2109 the Database Exchange process. In this case, restart the
2110 Database Exchange process by generating the neighbor event
2111 BadLSReq for the sending neighbor and stop processing the
2112 Link State Update packet. */
2113
2114 if (ospf_ls_request_lookup(nbr, lsa)) {
2115 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_BadLSReq);
2116 flog_warn(
2117 EC_OSPF_PACKET,
2118 "LSA[%s] instance exists on Link state request list",
2119 dump_lsa_key(lsa));
2120
2121 /* Clean list of LSAs. */
2122 ospf_upd_list_clean(lsas);
2123 /* this lsa is not on lsas list already. */
2124 ospf_lsa_discard(lsa);
2125 return;
2126 }
2127
2128 /* If the received LSA is the same instance as the database copy
2129 (i.e., neither one is more recent) the following two steps
2130 should be performed: */
2131
2132 if (ret == 0) {
2133 /* If the LSA is listed in the Link state retransmission
2134 list
2135 for the receiving adjacency, the router itself is
2136 expecting
2137 an acknowledgment for this LSA. The router should
2138 treat the
2139 received LSA as an acknowledgment by removing the LSA
2140 from
2141 the Link state retransmission list. This is termed
2142 an
2143 "implied acknowledgment". */
2144
2145 ls_ret = ospf_ls_retransmit_lookup(nbr, lsa);
2146
2147 if (ls_ret != NULL) {
2148 ospf_ls_retransmit_delete(nbr, ls_ret);
2149
2150 /* Delayed acknowledgment sent if advertisement
2151 received
2152 from Designated Router, otherwise do nothing.
2153 */
2154 if (oi->state == ISM_Backup)
2155 if (NBR_IS_DR(nbr))
2156 listnode_add(
2157 oi->ls_ack,
2158 ospf_lsa_lock(lsa));
2159
2160 DISCARD_LSA(lsa, 6);
2161 } else
2162 /* Acknowledge the receipt of the LSA by sending a
2163 Link State Acknowledgment packet back out the
2164 receiving
2165 interface. */
2166 {
2167 ospf_ls_ack_send(nbr, lsa);
2168 DISCARD_LSA(lsa, 7);
2169 }
2170 }
2171
2172 /* The database copy is more recent. If the database copy
2173 has LS age equal to MaxAge and LS sequence number equal to
2174 MaxSequenceNumber, simply discard the received LSA without
2175 acknowledging it. (In this case, the LSA's LS sequence number
2176 is
2177 wrapping, and the MaxSequenceNumber LSA must be completely
2178 flushed before any new LSA instance can be introduced). */
2179
2180 else if (ret > 0) /* Database copy is more recent */
2181 {
2182 if (IS_LSA_MAXAGE(current)
2183 && current->data->ls_seqnum
2184 == htonl(OSPF_MAX_SEQUENCE_NUMBER)) {
2185 DISCARD_LSA(lsa, 8);
2186 }
2187 /* Otherwise, as long as the database copy has not been
2188 sent in a
2189 Link State Update within the last MinLSArrival
2190 seconds, send the
2191 database copy back to the sending neighbor,
2192 encapsulated within
2193 a Link State Update Packet. The Link State Update
2194 Packet should
2195 be sent directly to the neighbor. In so doing, do not
2196 put the
2197 database copy of the LSA on the neighbor's link state
2198 retransmission list, and do not acknowledge the
2199 received (less
2200 recent) LSA instance. */
2201 else {
2202 if (monotime_since(&current->tv_orig, NULL)
2203 >= ospf->min_ls_arrival * 1000LL)
2204 /* Trap NSSA type later.*/
2205 ospf_ls_upd_send_lsa(
2206 nbr, current,
2207 OSPF_SEND_PACKET_DIRECT);
2208 DISCARD_LSA(lsa, 9);
2209 }
2210 }
2211 }
2212 #undef DISCARD_LSA
2213
2214 assert(listcount(lsas) == 0);
2215 list_delete(&lsas);
2216 }
2217
2218 /* OSPF Link State Acknowledgment message read -- RFC2328 Section 13.7. */
2219 static void ospf_ls_ack(struct ip *iph, struct ospf_header *ospfh,
2220 struct stream *s, struct ospf_interface *oi,
2221 uint16_t size)
2222 {
2223 struct ospf_neighbor *nbr;
2224
2225 /* increment statistics. */
2226 oi->ls_ack_in++;
2227
2228 nbr = ospf_nbr_lookup(oi, iph, ospfh);
2229 if (nbr == NULL) {
2230 flog_warn(EC_OSPF_PACKET,
2231 "Link State Acknowledgment: Unknown Neighbor %pI4",
2232 &ospfh->router_id);
2233 return;
2234 }
2235
2236 /* Add event to thread. */
2237 OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_PacketReceived);
2238
2239 if (nbr->state < NSM_Exchange) {
2240 if (IS_DEBUG_OSPF(nsm, NSM_EVENTS))
2241 zlog_debug(
2242 "Link State Acknowledgment: Neighbor[%pI4] state %s is less than Exchange",
2243 &ospfh->router_id,
2244 lookup_msg(ospf_nsm_state_msg, nbr->state,
2245 NULL));
2246 return;
2247 }
2248
2249 while (size >= OSPF_LSA_HEADER_SIZE) {
2250 struct ospf_lsa *lsa, *lsr;
2251
2252 lsa = ospf_lsa_new();
2253 lsa->data = (struct lsa_header *)stream_pnt(s);
2254 lsa->vrf_id = oi->ospf->vrf_id;
2255
2256 /* lsah = (struct lsa_header *) stream_pnt (s); */
2257 size -= OSPF_LSA_HEADER_SIZE;
2258 stream_forward_getp(s, OSPF_LSA_HEADER_SIZE);
2259
2260 if (lsa->data->type < OSPF_MIN_LSA
2261 || lsa->data->type >= OSPF_MAX_LSA) {
2262 lsa->data = NULL;
2263 ospf_lsa_discard(lsa);
2264 continue;
2265 }
2266
2267 lsr = ospf_ls_retransmit_lookup(nbr, lsa);
2268
2269 if (lsr != NULL && ospf_lsa_more_recent(lsr, lsa) == 0)
2270 ospf_ls_retransmit_delete(nbr, lsr);
2271
2272 lsa->data = NULL;
2273 ospf_lsa_discard(lsa);
2274 }
2275
2276 return;
2277 }
2278
2279 static struct stream *ospf_recv_packet(struct ospf *ospf, int fd,
2280 struct interface **ifp,
2281 struct stream *ibuf)
2282 {
2283 int ret;
2284 struct ip *iph;
2285 uint16_t ip_len;
2286 ifindex_t ifindex = 0;
2287 struct iovec iov;
2288 /* Header and data both require alignment. */
2289 char buff[CMSG_SPACE(SOPT_SIZE_CMSG_IFINDEX_IPV4())];
2290 struct msghdr msgh;
2291
2292 memset(&msgh, 0, sizeof(struct msghdr));
2293 msgh.msg_iov = &iov;
2294 msgh.msg_iovlen = 1;
2295 msgh.msg_control = (caddr_t)buff;
2296 msgh.msg_controllen = sizeof(buff);
2297
2298 ret = stream_recvmsg(ibuf, fd, &msgh, MSG_DONTWAIT,
2299 OSPF_MAX_PACKET_SIZE + 1);
2300 if (ret < 0) {
2301 if (errno != EAGAIN && errno != EWOULDBLOCK)
2302 flog_warn(EC_OSPF_PACKET, "stream_recvmsg failed: %s",
2303 safe_strerror(errno));
2304 return NULL;
2305 }
2306 if ((unsigned int)ret < sizeof(struct ip)) {
2307 flog_warn(
2308 EC_OSPF_PACKET,
2309 "ospf_recv_packet: discarding runt packet of length %d (ip header size is %u)",
2310 ret, (unsigned int)sizeof(iph));
2311 return NULL;
2312 }
2313
2314 /* Note that there should not be alignment problems with this assignment
2315 because this is at the beginning of the stream data buffer. */
2316 iph = (struct ip *)STREAM_DATA(ibuf);
2317 sockopt_iphdrincl_swab_systoh(iph);
2318
2319 ip_len = iph->ip_len;
2320
2321 #if defined(__FreeBSD__) && (__FreeBSD_version < 1000000)
2322 /*
2323 * Kernel network code touches incoming IP header parameters,
2324 * before protocol specific processing.
2325 *
2326 * 1) Convert byteorder to host representation.
2327 * --> ip_len, ip_id, ip_off
2328 *
2329 * 2) Adjust ip_len to strip IP header size!
2330 * --> If user process receives entire IP packet via RAW
2331 * socket, it must consider adding IP header size to
2332 * the "ip_len" field of "ip" structure.
2333 *
2334 * For more details, see <netinet/ip_input.c>.
2335 */
2336 ip_len = ip_len + (iph->ip_hl << 2);
2337 #endif
2338
2339 #if defined(__DragonFly__)
2340 /*
2341 * in DragonFly's raw socket, ip_len/ip_off are read
2342 * in network byte order.
2343 * As OpenBSD < 200311 adjust ip_len to strip IP header size!
2344 */
2345 ip_len = ntohs(iph->ip_len) + (iph->ip_hl << 2);
2346 #endif
2347
2348 ifindex = getsockopt_ifindex(AF_INET, &msgh);
2349
2350 *ifp = if_lookup_by_index(ifindex, ospf->vrf_id);
2351
2352 if (ret != ip_len) {
2353 flog_warn(
2354 EC_OSPF_PACKET,
2355 "ospf_recv_packet read length mismatch: ip_len is %d, but recvmsg returned %d",
2356 ip_len, ret);
2357 return NULL;
2358 }
2359
2360 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2361 zlog_debug("%s: fd %d(%s) on interface %d(%s)", __func__, fd,
2362 ospf_get_name(ospf), ifindex,
2363 *ifp ? (*ifp)->name : "Unknown");
2364 return ibuf;
2365 }
2366
2367 static struct ospf_interface *
2368 ospf_associate_packet_vl(struct ospf *ospf, struct interface *ifp,
2369 struct ip *iph, struct ospf_header *ospfh)
2370 {
2371 struct ospf_interface *rcv_oi;
2372 struct ospf_vl_data *vl_data;
2373 struct ospf_area *vl_area;
2374 struct listnode *node;
2375
2376 if (IN_MULTICAST(ntohl(iph->ip_dst.s_addr))
2377 || !OSPF_IS_AREA_BACKBONE(ospfh))
2378 return NULL;
2379
2380 /* look for local OSPF interface matching the destination
2381 * to determine Area ID. We presume therefore the destination address
2382 * is unique, or at least (for "unnumbered" links), not used in other
2383 * areas
2384 */
2385 if ((rcv_oi = ospf_if_lookup_by_local_addr(ospf, NULL, iph->ip_dst))
2386 == NULL)
2387 return NULL;
2388
2389 for (ALL_LIST_ELEMENTS_RO(ospf->vlinks, node, vl_data)) {
2390 vl_area =
2391 ospf_area_lookup_by_area_id(ospf, vl_data->vl_area_id);
2392 if (!vl_area)
2393 continue;
2394
2395 if (OSPF_AREA_SAME(&vl_area, &rcv_oi->area)
2396 && IPV4_ADDR_SAME(&vl_data->vl_peer, &ospfh->router_id)) {
2397 if (IS_DEBUG_OSPF_EVENT)
2398 zlog_debug("associating packet with %s",
2399 IF_NAME(vl_data->vl_oi));
2400 if (!CHECK_FLAG(vl_data->vl_oi->ifp->flags, IFF_UP)) {
2401 if (IS_DEBUG_OSPF_EVENT)
2402 zlog_debug(
2403 "This VL is not up yet, sorry");
2404 return NULL;
2405 }
2406
2407 return vl_data->vl_oi;
2408 }
2409 }
2410
2411 if (IS_DEBUG_OSPF_EVENT)
2412 zlog_debug("couldn't find any VL to associate the packet with");
2413
2414 return NULL;
2415 }
2416
2417 static int ospf_check_area_id(struct ospf_interface *oi,
2418 struct ospf_header *ospfh)
2419 {
2420 /* Check match the Area ID of the receiving interface. */
2421 if (OSPF_AREA_SAME(&oi->area, &ospfh))
2422 return 1;
2423
2424 return 0;
2425 }
2426
2427 /* Unbound socket will accept any Raw IP packets if proto is matched.
2428 To prevent it, compare src IP address and i/f address with masking
2429 i/f network mask. */
2430 static int ospf_check_network_mask(struct ospf_interface *oi,
2431 struct in_addr ip_src)
2432 {
2433 struct in_addr mask, me, him;
2434
2435 if (oi->type == OSPF_IFTYPE_POINTOPOINT
2436 || oi->type == OSPF_IFTYPE_VIRTUALLINK)
2437 return 1;
2438
2439 /* Ignore mask check for max prefix length (32) */
2440 if (oi->type == OSPF_IFTYPE_POINTOMULTIPOINT
2441 && oi->address->prefixlen == IPV4_MAX_BITLEN)
2442 return 1;
2443
2444 masklen2ip(oi->address->prefixlen, &mask);
2445
2446 me.s_addr = oi->address->u.prefix4.s_addr & mask.s_addr;
2447 him.s_addr = ip_src.s_addr & mask.s_addr;
2448
2449 if (IPV4_ADDR_SAME(&me, &him))
2450 return 1;
2451
2452 return 0;
2453 }
2454
2455 /* Return 1, if the packet is properly authenticated and checksummed,
2456 0 otherwise. In particular, check that AuType header field is valid and
2457 matches the locally configured AuType, and that D.5 requirements are met. */
2458 static int ospf_check_auth(struct ospf_interface *oi, struct ospf_header *ospfh)
2459 {
2460 struct crypt_key *ck;
2461 uint16_t iface_auth_type;
2462 uint16_t pkt_auth_type = ntohs(ospfh->auth_type);
2463
2464 switch (pkt_auth_type) {
2465 case OSPF_AUTH_NULL: /* RFC2328 D.5.1 */
2466 if (OSPF_AUTH_NULL != (iface_auth_type = ospf_auth_type(oi))) {
2467 if (IS_DEBUG_OSPF_PACKET(ospfh->type - 1, RECV))
2468 flog_warn(
2469 EC_OSPF_PACKET,
2470 "interface %s: auth-type mismatch, local %s, rcvd Null",
2471 IF_NAME(oi),
2472 lookup_msg(ospf_auth_type_str,
2473 iface_auth_type, NULL));
2474 return 0;
2475 }
2476 if (!ospf_check_sum(ospfh)) {
2477 if (IS_DEBUG_OSPF_PACKET(ospfh->type - 1, RECV))
2478 flog_warn(
2479 EC_OSPF_PACKET,
2480 "interface %s: Null auth OK, but checksum error, Router-ID %pI4",
2481 IF_NAME(oi),
2482 &ospfh->router_id);
2483 return 0;
2484 }
2485 return 1;
2486 case OSPF_AUTH_SIMPLE: /* RFC2328 D.5.2 */
2487 if (OSPF_AUTH_SIMPLE
2488 != (iface_auth_type = ospf_auth_type(oi))) {
2489 if (IS_DEBUG_OSPF_PACKET(ospfh->type - 1, RECV))
2490 flog_warn(
2491 EC_OSPF_PACKET,
2492 "interface %s: auth-type mismatch, local %s, rcvd Simple",
2493 IF_NAME(oi),
2494 lookup_msg(ospf_auth_type_str,
2495 iface_auth_type, NULL));
2496 return 0;
2497 }
2498 if (memcmp(OSPF_IF_PARAM(oi, auth_simple), ospfh->u.auth_data,
2499 OSPF_AUTH_SIMPLE_SIZE)) {
2500 if (IS_DEBUG_OSPF_PACKET(ospfh->type - 1, RECV))
2501 flog_warn(EC_OSPF_PACKET,
2502 "interface %s: Simple auth failed",
2503 IF_NAME(oi));
2504 return 0;
2505 }
2506 if (!ospf_check_sum(ospfh)) {
2507 if (IS_DEBUG_OSPF_PACKET(ospfh->type - 1, RECV))
2508 flog_warn(
2509 EC_OSPF_PACKET,
2510 "interface %s: Simple auth OK, checksum error, Router-ID %pI4",
2511 IF_NAME(oi),
2512 &ospfh->router_id);
2513 return 0;
2514 }
2515 return 1;
2516 case OSPF_AUTH_CRYPTOGRAPHIC: /* RFC2328 D.5.3 */
2517 if (OSPF_AUTH_CRYPTOGRAPHIC
2518 != (iface_auth_type = ospf_auth_type(oi))) {
2519 if (IS_DEBUG_OSPF_PACKET(ospfh->type - 1, RECV))
2520 flog_warn(
2521 EC_OSPF_PACKET,
2522 "interface %s: auth-type mismatch, local %s, rcvd Cryptographic",
2523 IF_NAME(oi),
2524 lookup_msg(ospf_auth_type_str,
2525 iface_auth_type, NULL));
2526 return 0;
2527 }
2528 if (ospfh->checksum) {
2529 if (IS_DEBUG_OSPF_PACKET(ospfh->type - 1, RECV))
2530 flog_warn(
2531 EC_OSPF_PACKET,
2532 "interface %s: OSPF header checksum is not 0",
2533 IF_NAME(oi));
2534 return 0;
2535 }
2536 /* only MD5 crypto method can pass ospf_packet_examin() */
2537 if (NULL == (ck = listgetdata(
2538 listtail(OSPF_IF_PARAM(oi, auth_crypt))))
2539 || ospfh->u.crypt.key_id != ck->key_id ||
2540 /* Condition above uses the last key ID on the list,
2541 which is
2542 different from what ospf_crypt_key_lookup() does. A
2543 bug? */
2544 !ospf_check_md5_digest(oi, ospfh)) {
2545 if (IS_DEBUG_OSPF_PACKET(ospfh->type - 1, RECV))
2546 flog_warn(EC_OSPF_MD5,
2547 "interface %s: MD5 auth failed",
2548 IF_NAME(oi));
2549 return 0;
2550 }
2551 return 1;
2552 default:
2553 if (IS_DEBUG_OSPF_PACKET(ospfh->type - 1, RECV))
2554 flog_warn(
2555 EC_OSPF_PACKET,
2556 "interface %s: invalid packet auth-type (%02x)",
2557 IF_NAME(oi), pkt_auth_type);
2558 return 0;
2559 }
2560 }
2561
2562 static int ospf_check_sum(struct ospf_header *ospfh)
2563 {
2564 uint32_t ret;
2565 uint16_t sum;
2566
2567 /* clear auth_data for checksum. */
2568 memset(ospfh->u.auth_data, 0, OSPF_AUTH_SIMPLE_SIZE);
2569
2570 /* keep checksum and clear. */
2571 sum = ospfh->checksum;
2572 memset(&ospfh->checksum, 0, sizeof(uint16_t));
2573
2574 /* calculate checksum. */
2575 ret = in_cksum(ospfh, ntohs(ospfh->length));
2576
2577 if (ret != sum) {
2578 zlog_info("ospf_check_sum(): checksum mismatch, my %X, his %X",
2579 ret, sum);
2580 return 0;
2581 }
2582
2583 return 1;
2584 }
2585
2586 /* Verify, that given link/TOS records are properly sized/aligned and match
2587 Router-LSA "# links" and "# TOS" fields as specified in RFC2328 A.4.2. */
2588 static unsigned ospf_router_lsa_links_examin(struct router_lsa_link *link,
2589 uint16_t linkbytes,
2590 const uint16_t num_links)
2591 {
2592 unsigned counted_links = 0, thislinklen;
2593
2594 while (linkbytes >= OSPF_ROUTER_LSA_LINK_SIZE) {
2595 thislinklen =
2596 OSPF_ROUTER_LSA_LINK_SIZE + 4 * link->m[0].tos_count;
2597 if (thislinklen > linkbytes) {
2598 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2599 zlog_debug("%s: length error in link block #%u",
2600 __func__, counted_links);
2601 return MSG_NG;
2602 }
2603 link = (struct router_lsa_link *)((caddr_t)link + thislinklen);
2604 linkbytes -= thislinklen;
2605 counted_links++;
2606 }
2607 if (counted_links != num_links) {
2608 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2609 zlog_debug("%s: %u link blocks declared, %u present",
2610 __func__, num_links, counted_links);
2611 return MSG_NG;
2612 }
2613 return MSG_OK;
2614 }
2615
2616 /* Verify, that the given LSA is properly sized/aligned (including type-specific
2617 minimum length constraint). */
2618 static unsigned ospf_lsa_examin(struct lsa_header *lsah, const uint16_t lsalen,
2619 const uint8_t headeronly)
2620 {
2621 unsigned ret;
2622 struct router_lsa *rlsa;
2623 if (lsah->type < OSPF_MAX_LSA && ospf_lsa_minlen[lsah->type]
2624 && lsalen < OSPF_LSA_HEADER_SIZE + ospf_lsa_minlen[lsah->type]) {
2625 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2626 zlog_debug("%s: undersized (%u B) %s", __func__, lsalen,
2627 lookup_msg(ospf_lsa_type_msg, lsah->type,
2628 NULL));
2629 return MSG_NG;
2630 }
2631 switch (lsah->type) {
2632 case OSPF_ROUTER_LSA: {
2633 /*
2634 * RFC2328 A.4.2, LSA header + 4 bytes followed by N>=0
2635 * (12+)-byte link blocks
2636 */
2637 size_t linkbytes_len = lsalen - OSPF_LSA_HEADER_SIZE
2638 - OSPF_ROUTER_LSA_MIN_SIZE;
2639
2640 /*
2641 * LSA link blocks are variable length but always multiples of
2642 * 4; basic sanity check
2643 */
2644 if (linkbytes_len % 4 != 0)
2645 return MSG_NG;
2646
2647 if (headeronly)
2648 return MSG_OK;
2649
2650 rlsa = (struct router_lsa *)lsah;
2651
2652 ret = ospf_router_lsa_links_examin(
2653 (struct router_lsa_link *)rlsa->link,
2654 linkbytes_len,
2655 ntohs(rlsa->links));
2656 break;
2657 }
2658 case OSPF_AS_EXTERNAL_LSA:
2659 /* RFC2328 A.4.5, LSA header + 4 bytes followed by N>=1 12-bytes long
2660 * blocks */
2661 case OSPF_AS_NSSA_LSA:
2662 /* RFC3101 C, idem */
2663 ret = (lsalen - OSPF_LSA_HEADER_SIZE
2664 - OSPF_AS_EXTERNAL_LSA_MIN_SIZE)
2665 % 12
2666 ? MSG_NG
2667 : MSG_OK;
2668 break;
2669 /* Following LSA types are considered OK length-wise as soon as their
2670 * minimum
2671 * length constraint is met and length of the whole LSA is a multiple of
2672 * 4
2673 * (basic LSA header size is already a multiple of 4). */
2674 case OSPF_NETWORK_LSA:
2675 /* RFC2328 A.4.3, LSA header + 4 bytes followed by N>=1 router-IDs */
2676 case OSPF_SUMMARY_LSA:
2677 case OSPF_ASBR_SUMMARY_LSA:
2678 /* RFC2328 A.4.4, LSA header + 4 bytes followed by N>=1 4-bytes TOS
2679 * blocks */
2680 case OSPF_OPAQUE_LINK_LSA:
2681 case OSPF_OPAQUE_AREA_LSA:
2682 case OSPF_OPAQUE_AS_LSA:
2683 /* RFC5250 A.2, "some number of octets (of application-specific
2684 * data) padded to 32-bit alignment." This is considered
2685 * equivalent
2686 * to 4-byte alignment of all other LSA types, see
2687 * OSPF-ALIGNMENT.txt
2688 * file for the detailed analysis of this passage. */
2689 ret = lsalen % 4 ? MSG_NG : MSG_OK;
2690 break;
2691 default:
2692 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2693 zlog_debug("%s: unsupported LSA type 0x%02x", __func__,
2694 lsah->type);
2695 return MSG_NG;
2696 }
2697 if (ret != MSG_OK && IS_DEBUG_OSPF_PACKET(0, RECV))
2698 zlog_debug("%s: alignment error in %s", __func__,
2699 lookup_msg(ospf_lsa_type_msg, lsah->type, NULL));
2700 return ret;
2701 }
2702
2703 /* Verify if the provided input buffer is a valid sequence of LSAs. This
2704 includes verification of LSA blocks length/alignment and dispatching
2705 of deeper-level checks. */
2706 static unsigned
2707 ospf_lsaseq_examin(struct lsa_header *lsah, /* start of buffered data */
2708 size_t length, const uint8_t headeronly,
2709 /* When declared_num_lsas is not 0, compare it to the real
2710 number of LSAs
2711 and treat the difference as an error. */
2712 const uint32_t declared_num_lsas)
2713 {
2714 uint32_t counted_lsas = 0;
2715
2716 while (length) {
2717 uint16_t lsalen;
2718 if (length < OSPF_LSA_HEADER_SIZE) {
2719 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2720 zlog_debug(
2721 "%s: undersized (%zu B) trailing (#%u) LSA header",
2722 __func__, length, counted_lsas);
2723 return MSG_NG;
2724 }
2725 /* save on ntohs() calls here and in the LSA validator */
2726 lsalen = ntohs(lsah->length);
2727 if (lsalen < OSPF_LSA_HEADER_SIZE) {
2728 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2729 zlog_debug(
2730 "%s: malformed LSA header #%u, declared length is %u B",
2731 __func__, counted_lsas, lsalen);
2732 return MSG_NG;
2733 }
2734 if (headeronly) {
2735 /* less checks here and in ospf_lsa_examin() */
2736 if (MSG_OK != ospf_lsa_examin(lsah, lsalen, 1)) {
2737 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2738 zlog_debug(
2739 "%s: malformed header-only LSA #%u",
2740 __func__, counted_lsas);
2741 return MSG_NG;
2742 }
2743 lsah = (struct lsa_header *)((caddr_t)lsah
2744 + OSPF_LSA_HEADER_SIZE);
2745 length -= OSPF_LSA_HEADER_SIZE;
2746 } else {
2747 /* make sure the input buffer is deep enough before
2748 * further checks */
2749 if (lsalen > length) {
2750 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2751 zlog_debug(
2752 "%s: anomaly in LSA #%u: declared length is %u B, buffered length is %zu B",
2753 __func__, counted_lsas, lsalen,
2754 length);
2755 return MSG_NG;
2756 }
2757 if (MSG_OK != ospf_lsa_examin(lsah, lsalen, 0)) {
2758 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2759 zlog_debug("%s: malformed LSA #%u",
2760 __func__, counted_lsas);
2761 return MSG_NG;
2762 }
2763 lsah = (struct lsa_header *)((caddr_t)lsah + lsalen);
2764 length -= lsalen;
2765 }
2766 counted_lsas++;
2767 }
2768
2769 if (declared_num_lsas && counted_lsas != declared_num_lsas) {
2770 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2771 zlog_debug(
2772 "%s: #LSAs declared (%u) does not match actual (%u)",
2773 __func__, declared_num_lsas, counted_lsas);
2774 return MSG_NG;
2775 }
2776 return MSG_OK;
2777 }
2778
2779 /* Verify a complete OSPF packet for proper sizing/alignment. */
2780 static unsigned ospf_packet_examin(struct ospf_header *oh,
2781 const unsigned bytesonwire)
2782 {
2783 uint16_t bytesdeclared, bytesauth;
2784 unsigned ret;
2785 struct ospf_ls_update *lsupd;
2786
2787 /* Length, 1st approximation. */
2788 if (bytesonwire < OSPF_HEADER_SIZE) {
2789 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2790 zlog_debug("%s: undersized (%u B) packet", __func__,
2791 bytesonwire);
2792 return MSG_NG;
2793 }
2794 /* Now it is safe to access header fields. Performing length check,
2795 * allow
2796 * for possible extra bytes of crypto auth/padding, which are not
2797 * counted
2798 * in the OSPF header "length" field. */
2799 if (oh->version != OSPF_VERSION) {
2800 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2801 zlog_debug("%s: invalid (%u) protocol version",
2802 __func__, oh->version);
2803 return MSG_NG;
2804 }
2805 bytesdeclared = ntohs(oh->length);
2806 if (ntohs(oh->auth_type) != OSPF_AUTH_CRYPTOGRAPHIC)
2807 bytesauth = 0;
2808 else {
2809 if (oh->u.crypt.auth_data_len != OSPF_AUTH_MD5_SIZE) {
2810 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2811 zlog_debug(
2812 "%s: unsupported crypto auth length (%u B)",
2813 __func__, oh->u.crypt.auth_data_len);
2814 return MSG_NG;
2815 }
2816 bytesauth = OSPF_AUTH_MD5_SIZE;
2817 }
2818 if (bytesdeclared + bytesauth > bytesonwire) {
2819 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2820 zlog_debug(
2821 "%s: packet length error (%u real, %u+%u declared)",
2822 __func__, bytesonwire, bytesdeclared,
2823 bytesauth);
2824 return MSG_NG;
2825 }
2826 /* Length, 2nd approximation. The type-specific constraint is checked
2827 against declared length, not amount of bytes on wire. */
2828 if (oh->type >= OSPF_MSG_HELLO && oh->type <= OSPF_MSG_LS_ACK
2829 && bytesdeclared
2830 < OSPF_HEADER_SIZE + ospf_packet_minlen[oh->type]) {
2831 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2832 zlog_debug("%s: undersized (%u B) %s packet", __func__,
2833 bytesdeclared,
2834 lookup_msg(ospf_packet_type_str, oh->type,
2835 NULL));
2836 return MSG_NG;
2837 }
2838 switch (oh->type) {
2839 case OSPF_MSG_HELLO:
2840 /* RFC2328 A.3.2, packet header + OSPF_HELLO_MIN_SIZE bytes
2841 followed
2842 by N>=0 router-IDs. */
2843 ret = (bytesdeclared - OSPF_HEADER_SIZE - OSPF_HELLO_MIN_SIZE)
2844 % 4
2845 ? MSG_NG
2846 : MSG_OK;
2847 break;
2848 case OSPF_MSG_DB_DESC:
2849 /* RFC2328 A.3.3, packet header + OSPF_DB_DESC_MIN_SIZE bytes
2850 followed
2851 by N>=0 header-only LSAs. */
2852 ret = ospf_lsaseq_examin(
2853 (struct lsa_header *)((caddr_t)oh + OSPF_HEADER_SIZE
2854 + OSPF_DB_DESC_MIN_SIZE),
2855 bytesdeclared - OSPF_HEADER_SIZE
2856 - OSPF_DB_DESC_MIN_SIZE,
2857 1, /* header-only LSAs */
2858 0);
2859 break;
2860 case OSPF_MSG_LS_REQ:
2861 /* RFC2328 A.3.4, packet header followed by N>=0 12-bytes
2862 * request blocks. */
2863 ret = (bytesdeclared - OSPF_HEADER_SIZE - OSPF_LS_REQ_MIN_SIZE)
2864 % OSPF_LSA_KEY_SIZE
2865 ? MSG_NG
2866 : MSG_OK;
2867 break;
2868 case OSPF_MSG_LS_UPD:
2869 /* RFC2328 A.3.5, packet header + OSPF_LS_UPD_MIN_SIZE bytes
2870 followed
2871 by N>=0 full LSAs (with N declared beforehand). */
2872 lsupd = (struct ospf_ls_update *)((caddr_t)oh
2873 + OSPF_HEADER_SIZE);
2874 ret = ospf_lsaseq_examin(
2875 (struct lsa_header *)((caddr_t)lsupd
2876 + OSPF_LS_UPD_MIN_SIZE),
2877 bytesdeclared - OSPF_HEADER_SIZE - OSPF_LS_UPD_MIN_SIZE,
2878 0, /* full LSAs */
2879 ntohl(lsupd->num_lsas) /* 32 bits */
2880 );
2881 break;
2882 case OSPF_MSG_LS_ACK:
2883 /* RFC2328 A.3.6, packet header followed by N>=0 header-only
2884 * LSAs. */
2885 ret = ospf_lsaseq_examin(
2886 (struct lsa_header *)((caddr_t)oh + OSPF_HEADER_SIZE
2887 + OSPF_LS_ACK_MIN_SIZE),
2888 bytesdeclared - OSPF_HEADER_SIZE - OSPF_LS_ACK_MIN_SIZE,
2889 1, /* header-only LSAs */
2890 0);
2891 break;
2892 default:
2893 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2894 zlog_debug("%s: invalid packet type 0x%02x", __func__,
2895 oh->type);
2896 return MSG_NG;
2897 }
2898 if (ret != MSG_OK && IS_DEBUG_OSPF_PACKET(0, RECV))
2899 zlog_debug("%s: malformed %s packet", __func__,
2900 lookup_msg(ospf_packet_type_str, oh->type, NULL));
2901 return ret;
2902 }
2903
2904 /* OSPF Header verification. */
2905 static int ospf_verify_header(struct stream *ibuf, struct ospf_interface *oi,
2906 struct ip *iph, struct ospf_header *ospfh)
2907 {
2908 /* Check Area ID. */
2909 if (!ospf_check_area_id(oi, ospfh)) {
2910 flog_warn(EC_OSPF_PACKET,
2911 "interface %s: ospf_read invalid Area ID %pI4",
2912 IF_NAME(oi), &ospfh->area_id);
2913 return -1;
2914 }
2915
2916 /* Check network mask, Silently discarded. */
2917 if (!ospf_check_network_mask(oi, iph->ip_src)) {
2918 flog_warn(
2919 EC_OSPF_PACKET,
2920 "interface %s: ospf_read network address is not same [%pI4]",
2921 IF_NAME(oi), &iph->ip_src);
2922 return -1;
2923 }
2924
2925 /* Check authentication. The function handles logging actions, where
2926 * required. */
2927 if (!ospf_check_auth(oi, ospfh))
2928 return -1;
2929
2930 return 0;
2931 }
2932
2933 enum ospf_read_return_enum {
2934 OSPF_READ_ERROR,
2935 OSPF_READ_CONTINUE,
2936 };
2937
2938 static enum ospf_read_return_enum ospf_read_helper(struct ospf *ospf)
2939 {
2940 int ret;
2941 struct stream *ibuf;
2942 struct ospf_interface *oi;
2943 struct ip *iph;
2944 struct ospf_header *ospfh;
2945 uint16_t length;
2946 struct connected *c;
2947 struct interface *ifp = NULL;
2948
2949 stream_reset(ospf->ibuf);
2950 ibuf = ospf_recv_packet(ospf, ospf->fd, &ifp, ospf->ibuf);
2951 if (ibuf == NULL)
2952 return OSPF_READ_ERROR;
2953
2954 /*
2955 * This raw packet is known to be at least as big as its
2956 * IP header. Note that there should not be alignment problems with
2957 * this assignment because this is at the beginning of the
2958 * stream data buffer.
2959 */
2960 iph = (struct ip *)STREAM_DATA(ibuf);
2961 /*
2962 * Note that sockopt_iphdrincl_swab_systoh was called in
2963 * ospf_recv_packet.
2964 */
2965 if (ifp == NULL) {
2966 /*
2967 * Handle cases where the platform does not support
2968 * retrieving the ifindex, and also platforms (such as
2969 * Solaris 8) that claim to support ifindex retrieval but do
2970 * not.
2971 */
2972 c = if_lookup_address((void *)&iph->ip_src, AF_INET,
2973 ospf->vrf_id);
2974 if (c)
2975 ifp = c->ifp;
2976 if (ifp == NULL) {
2977 if (IS_DEBUG_OSPF_PACKET(0, RECV))
2978 zlog_debug(
2979 "%s: Unable to determine incoming interface from: %pI4(%s)",
2980 __func__, &iph->ip_src,
2981 ospf_get_name(ospf));
2982 return OSPF_READ_CONTINUE;
2983 }
2984 }
2985
2986 if (ospf->vrf_id == VRF_DEFAULT && ospf->vrf_id != ifp->vrf_id) {
2987 /*
2988 * We may have a situation where l3mdev_accept == 1
2989 * let's just kindly drop the packet and move on.
2990 * ospf really really really does not like when
2991 * we receive the same packet multiple times.
2992 */
2993 return OSPF_READ_CONTINUE;
2994 }
2995
2996 /* Self-originated packet should be discarded silently. */
2997 if (ospf_if_lookup_by_local_addr(ospf, NULL, iph->ip_src)) {
2998 if (IS_DEBUG_OSPF_PACKET(0, RECV)) {
2999 zlog_debug(
3000 "ospf_read[%pI4]: Dropping self-originated packet",
3001 &iph->ip_src);
3002 }
3003 return OSPF_READ_CONTINUE;
3004 }
3005
3006 /* Check that we have enough for an IP header */
3007 if ((unsigned int)(iph->ip_hl << 2) >= STREAM_READABLE(ibuf)) {
3008 if ((unsigned int)(iph->ip_hl << 2) == STREAM_READABLE(ibuf)) {
3009 flog_warn(
3010 EC_OSPF_PACKET,
3011 "Rx'd IP packet with OSPF protocol number but no payload");
3012 } else {
3013 flog_warn(
3014 EC_OSPF_PACKET,
3015 "IP header length field claims header is %u bytes, but we only have %zu",
3016 (unsigned int)(iph->ip_hl << 2),
3017 STREAM_READABLE(ibuf));
3018 }
3019
3020 return OSPF_READ_ERROR;
3021 }
3022 stream_forward_getp(ibuf, iph->ip_hl << 2);
3023
3024 ospfh = (struct ospf_header *)stream_pnt(ibuf);
3025 if (MSG_OK
3026 != ospf_packet_examin(ospfh, stream_get_endp(ibuf)
3027 - stream_get_getp(ibuf)))
3028 return OSPF_READ_CONTINUE;
3029 /* Now it is safe to access all fields of OSPF packet header. */
3030
3031 /* associate packet with ospf interface */
3032 oi = ospf_if_lookup_recv_if(ospf, iph->ip_src, ifp);
3033
3034 /*
3035 * ospf_verify_header() relies on a valid "oi" and thus can be called
3036 * only after the passive/backbone/other checks below are passed.
3037 * These checks in turn access the fields of unverified "ospfh"
3038 * structure for their own purposes and must remain very accurate
3039 * in doing this.
3040 */
3041
3042 /* If incoming interface is passive one, ignore it. */
3043 if (oi && OSPF_IF_PASSIVE_STATUS(oi) == OSPF_IF_PASSIVE) {
3044 if (IS_DEBUG_OSPF_EVENT)
3045 zlog_debug(
3046 "ignoring packet from router %pI4 sent to %pI4, received on a passive interface, %pI4",
3047 &ospfh->router_id, &iph->ip_dst,
3048 &oi->address->u.prefix4);
3049
3050 if (iph->ip_dst.s_addr == htonl(OSPF_ALLSPFROUTERS)) {
3051 /* Try to fix multicast membership.
3052 * Some OS:es may have problems in this area,
3053 * make sure it is removed.
3054 */
3055 OI_MEMBER_JOINED(oi, MEMBER_ALLROUTERS);
3056 ospf_if_set_multicast(oi);
3057 }
3058 return OSPF_READ_CONTINUE;
3059 }
3060
3061
3062 /* if no local ospf_interface,
3063 * or header area is backbone but ospf_interface is not
3064 * check for VLINK interface
3065 */
3066 if ((oi == NULL)
3067 || (OSPF_IS_AREA_ID_BACKBONE(ospfh->area_id)
3068 && !OSPF_IS_AREA_ID_BACKBONE(oi->area->area_id))) {
3069 if ((oi = ospf_associate_packet_vl(ospf, ifp, iph, ospfh))
3070 == NULL) {
3071 if (!ospf->instance && IS_DEBUG_OSPF_EVENT)
3072 zlog_debug(
3073 "Packet from [%pI4] received on link %s but no ospf_interface",
3074 &iph->ip_src, ifp->name);
3075 return OSPF_READ_CONTINUE;
3076 }
3077 }
3078
3079 /*
3080 * else it must be a local ospf interface, check it was
3081 * received on correct link
3082 */
3083 else if (oi->ifp != ifp) {
3084 if (IS_DEBUG_OSPF_EVENT)
3085 flog_warn(EC_OSPF_PACKET,
3086 "Packet from [%pI4] received on wrong link %s",
3087 &iph->ip_src, ifp->name);
3088 return OSPF_READ_CONTINUE;
3089 } else if (oi->state == ISM_Down) {
3090 flog_warn(
3091 EC_OSPF_PACKET,
3092 "Ignoring packet from %pI4 to %pI4 received on interface that is down [%s]; interface flags are %s",
3093 &iph->ip_src, &iph->ip_dst, ifp->name,
3094 if_flag_dump(ifp->flags));
3095 /* Fix multicast memberships? */
3096 if (iph->ip_dst.s_addr == htonl(OSPF_ALLSPFROUTERS))
3097 OI_MEMBER_JOINED(oi, MEMBER_ALLROUTERS);
3098 else if (iph->ip_dst.s_addr == htonl(OSPF_ALLDROUTERS))
3099 OI_MEMBER_JOINED(oi, MEMBER_DROUTERS);
3100 if (oi->multicast_memberships)
3101 ospf_if_set_multicast(oi);
3102 return OSPF_READ_CONTINUE;
3103 }
3104
3105 /*
3106 * If the received packet is destined for AllDRouters, the
3107 * packet should be accepted only if the received ospf
3108 * interface state is either DR or Backup -- endo.
3109 *
3110 * I wonder who endo is?
3111 */
3112 if (iph->ip_dst.s_addr == htonl(OSPF_ALLDROUTERS)
3113 && (oi->state != ISM_DR && oi->state != ISM_Backup)) {
3114 flog_warn(
3115 EC_OSPF_PACKET,
3116 "Dropping packet for AllDRouters from [%pI4] via [%s] (ISM: %s)",
3117 &iph->ip_src, IF_NAME(oi),
3118 lookup_msg(ospf_ism_state_msg, oi->state, NULL));
3119 /* Try to fix multicast membership. */
3120 SET_FLAG(oi->multicast_memberships, MEMBER_DROUTERS);
3121 ospf_if_set_multicast(oi);
3122 return OSPF_READ_CONTINUE;
3123 }
3124
3125 /* Verify more OSPF header fields. */
3126 ret = ospf_verify_header(ibuf, oi, iph, ospfh);
3127 if (ret < 0) {
3128 if (IS_DEBUG_OSPF_PACKET(0, RECV))
3129 zlog_debug(
3130 "ospf_read[%pI4]: Header check failed, dropping.",
3131 &iph->ip_src);
3132 return OSPF_READ_CONTINUE;
3133 }
3134
3135 /* Show debug receiving packet. */
3136 if (IS_DEBUG_OSPF_PACKET(ospfh->type - 1, RECV)) {
3137 if (IS_DEBUG_OSPF_PACKET(ospfh->type - 1, DETAIL)) {
3138 zlog_debug(
3139 "-----------------------------------------------------");
3140 ospf_packet_dump(ibuf);
3141 }
3142
3143 zlog_debug("%s received from [%pI4] via [%s]",
3144 lookup_msg(ospf_packet_type_str, ospfh->type, NULL),
3145 &ospfh->router_id, IF_NAME(oi));
3146 zlog_debug(" src [%pI4],", &iph->ip_src);
3147 zlog_debug(" dst [%pI4]", &iph->ip_dst);
3148
3149 if (IS_DEBUG_OSPF_PACKET(ospfh->type - 1, DETAIL))
3150 zlog_debug(
3151 "-----------------------------------------------------");
3152 }
3153
3154 stream_forward_getp(ibuf, OSPF_HEADER_SIZE);
3155
3156 /* Adjust size to message length. */
3157 length = ntohs(ospfh->length) - OSPF_HEADER_SIZE;
3158
3159 /* Read rest of the packet and call each sort of packet routine.
3160 */
3161 switch (ospfh->type) {
3162 case OSPF_MSG_HELLO:
3163 ospf_hello(iph, ospfh, ibuf, oi, length);
3164 break;
3165 case OSPF_MSG_DB_DESC:
3166 ospf_db_desc(iph, ospfh, ibuf, oi, length);
3167 break;
3168 case OSPF_MSG_LS_REQ:
3169 ospf_ls_req(iph, ospfh, ibuf, oi, length);
3170 break;
3171 case OSPF_MSG_LS_UPD:
3172 ospf_ls_upd(ospf, iph, ospfh, ibuf, oi, length);
3173 break;
3174 case OSPF_MSG_LS_ACK:
3175 ospf_ls_ack(iph, ospfh, ibuf, oi, length);
3176 break;
3177 default:
3178 flog_warn(
3179 EC_OSPF_PACKET,
3180 "interface %s(%s): OSPF packet header type %d is illegal",
3181 IF_NAME(oi), ospf_get_name(ospf), ospfh->type);
3182 break;
3183 }
3184
3185 return OSPF_READ_CONTINUE;
3186 }
3187
3188 /* Starting point of packet process function. */
3189 int ospf_read(struct thread *thread)
3190 {
3191 struct ospf *ospf;
3192 int32_t count = 0;
3193 enum ospf_read_return_enum ret;
3194
3195 /* first of all get interface pointer. */
3196 ospf = THREAD_ARG(thread);
3197
3198 /* prepare for next packet. */
3199 thread_add_read(master, ospf_read, ospf, ospf->fd, &ospf->t_read);
3200
3201 while (count < ospf->write_oi_count) {
3202 count++;
3203 ret = ospf_read_helper(ospf);
3204 switch (ret) {
3205 case OSPF_READ_ERROR:
3206 return -1;
3207 case OSPF_READ_CONTINUE:
3208 break;
3209 }
3210 }
3211
3212 return 0;
3213 }
3214
3215 /* Make OSPF header. */
3216 static void ospf_make_header(int type, struct ospf_interface *oi,
3217 struct stream *s)
3218 {
3219 struct ospf_header *ospfh;
3220
3221 ospfh = (struct ospf_header *)STREAM_DATA(s);
3222
3223 ospfh->version = (uint8_t)OSPF_VERSION;
3224 ospfh->type = (uint8_t)type;
3225
3226 ospfh->router_id = oi->ospf->router_id;
3227
3228 ospfh->checksum = 0;
3229 ospfh->area_id = oi->area->area_id;
3230 ospfh->auth_type = htons(ospf_auth_type(oi));
3231
3232 memset(ospfh->u.auth_data, 0, OSPF_AUTH_SIMPLE_SIZE);
3233
3234 stream_forward_endp(s, OSPF_HEADER_SIZE);
3235 }
3236
3237 /* Make Authentication Data. */
3238 static int ospf_make_auth(struct ospf_interface *oi, struct ospf_header *ospfh)
3239 {
3240 struct crypt_key *ck;
3241
3242 switch (ospf_auth_type(oi)) {
3243 case OSPF_AUTH_NULL:
3244 /* memset (ospfh->u.auth_data, 0, sizeof(ospfh->u.auth_data));
3245 */
3246 break;
3247 case OSPF_AUTH_SIMPLE:
3248 memcpy(ospfh->u.auth_data, OSPF_IF_PARAM(oi, auth_simple),
3249 OSPF_AUTH_SIMPLE_SIZE);
3250 break;
3251 case OSPF_AUTH_CRYPTOGRAPHIC:
3252 /* If key is not set, then set 0. */
3253 if (list_isempty(OSPF_IF_PARAM(oi, auth_crypt))) {
3254 ospfh->u.crypt.zero = 0;
3255 ospfh->u.crypt.key_id = 0;
3256 ospfh->u.crypt.auth_data_len = OSPF_AUTH_MD5_SIZE;
3257 } else {
3258 ck = listgetdata(
3259 listtail(OSPF_IF_PARAM(oi, auth_crypt)));
3260 ospfh->u.crypt.zero = 0;
3261 ospfh->u.crypt.key_id = ck->key_id;
3262 ospfh->u.crypt.auth_data_len = OSPF_AUTH_MD5_SIZE;
3263 }
3264 /* note: the seq is done in ospf_make_md5_digest() */
3265 break;
3266 default:
3267 /* memset (ospfh->u.auth_data, 0, sizeof(ospfh->u.auth_data));
3268 */
3269 break;
3270 }
3271
3272 return 0;
3273 }
3274
3275 /* Fill rest of OSPF header. */
3276 static void ospf_fill_header(struct ospf_interface *oi, struct stream *s,
3277 uint16_t length)
3278 {
3279 struct ospf_header *ospfh;
3280
3281 ospfh = (struct ospf_header *)STREAM_DATA(s);
3282
3283 /* Fill length. */
3284 ospfh->length = htons(length);
3285
3286 /* Calculate checksum. */
3287 if (ntohs(ospfh->auth_type) != OSPF_AUTH_CRYPTOGRAPHIC)
3288 ospfh->checksum = in_cksum(ospfh, length);
3289 else
3290 ospfh->checksum = 0;
3291
3292 /* Add Authentication Data. */
3293 ospf_make_auth(oi, ospfh);
3294 }
3295
3296 static int ospf_make_hello(struct ospf_interface *oi, struct stream *s)
3297 {
3298 struct ospf_neighbor *nbr;
3299 struct route_node *rn;
3300 uint16_t length = OSPF_HELLO_MIN_SIZE;
3301 struct in_addr mask;
3302 unsigned long p;
3303 int flag = 0;
3304
3305 /* Set netmask of interface. */
3306 if (!(CHECK_FLAG(oi->connected->flags, ZEBRA_IFA_UNNUMBERED)
3307 && oi->type == OSPF_IFTYPE_POINTOPOINT)
3308 && oi->type != OSPF_IFTYPE_VIRTUALLINK)
3309 masklen2ip(oi->address->prefixlen, &mask);
3310 else
3311 memset((char *)&mask, 0, sizeof(struct in_addr));
3312 stream_put_ipv4(s, mask.s_addr);
3313
3314 /* Set Hello Interval. */
3315 if (OSPF_IF_PARAM(oi, fast_hello) == 0)
3316 stream_putw(s, OSPF_IF_PARAM(oi, v_hello));
3317 else
3318 stream_putw(s, 0); /* hello-interval of 0 for fast-hellos */
3319
3320 if (IS_DEBUG_OSPF_EVENT)
3321 zlog_debug("make_hello: options: %x, int: %s", OPTIONS(oi),
3322 IF_NAME(oi));
3323
3324 /* Set Options. */
3325 stream_putc(s, OPTIONS(oi));
3326
3327 /* Set Router Priority. */
3328 stream_putc(s, PRIORITY(oi));
3329
3330 /* Set Router Dead Interval. */
3331 stream_putl(s, OSPF_IF_PARAM(oi, v_wait));
3332
3333 /* Set Designated Router. */
3334 stream_put_ipv4(s, DR(oi).s_addr);
3335
3336 p = stream_get_endp(s);
3337
3338 /* Set Backup Designated Router. */
3339 stream_put_ipv4(s, BDR(oi).s_addr);
3340
3341 /* Add neighbor seen. */
3342 for (rn = route_top(oi->nbrs); rn; rn = route_next(rn))
3343 if ((nbr = rn->info))
3344 if (nbr->router_id.s_addr
3345 != INADDR_ANY) /* Ignore 0.0.0.0 node. */
3346 if (nbr->state
3347 != NSM_Attempt) /* Ignore Down neighbor. */
3348 if (nbr->state
3349 != NSM_Down) /* This is myself for
3350 DR election. */
3351 if (!IPV4_ADDR_SAME(
3352 &nbr->router_id,
3353 &oi->ospf->router_id)) {
3354 /* Check neighbor is
3355 * sane? */
3356 if (nbr->d_router.s_addr
3357 != INADDR_ANY
3358 && IPV4_ADDR_SAME(
3359 &nbr->d_router,
3360 &oi->address
3361 ->u
3362 .prefix4)
3363 && IPV4_ADDR_SAME(
3364 &nbr->bd_router,
3365 &oi->address
3366 ->u
3367 .prefix4))
3368 flag = 1;
3369
3370 /* Hello packet overflows interface MTU. */
3371 if (length + sizeof(uint32_t)
3372 > ospf_packet_max(oi)) {
3373 flog_err(
3374 EC_OSPF_LARGE_HELLO,
3375 "Oversized Hello packet! Larger than MTU. Not sending it out");
3376 return 0;
3377 }
3378
3379 stream_put_ipv4(
3380 s,
3381 nbr->router_id
3382 .s_addr);
3383 length += 4;
3384 }
3385
3386 /* Let neighbor generate BackupSeen. */
3387 if (flag == 1)
3388 stream_putl_at(s, p, 0); /* ipv4 address, normally */
3389
3390 return length;
3391 }
3392
3393 static int ospf_make_db_desc(struct ospf_interface *oi,
3394 struct ospf_neighbor *nbr, struct stream *s)
3395 {
3396 struct ospf_lsa *lsa;
3397 uint16_t length = OSPF_DB_DESC_MIN_SIZE;
3398 uint8_t options;
3399 unsigned long pp;
3400 int i;
3401 struct ospf_lsdb *lsdb;
3402
3403 /* Set Interface MTU. */
3404 if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
3405 stream_putw(s, 0);
3406 else
3407 stream_putw(s, oi->ifp->mtu);
3408
3409 /* Set Options. */
3410 options = OPTIONS(oi);
3411 if (CHECK_FLAG(oi->ospf->config, OSPF_OPAQUE_CAPABLE))
3412 SET_FLAG(options, OSPF_OPTION_O);
3413 stream_putc(s, options);
3414
3415 /* DD flags */
3416 pp = stream_get_endp(s);
3417 stream_putc(s, nbr->dd_flags);
3418
3419 /* Set DD Sequence Number. */
3420 stream_putl(s, nbr->dd_seqnum);
3421
3422 /* shortcut unneeded walk of (empty) summary LSDBs */
3423 if (ospf_db_summary_isempty(nbr))
3424 goto empty;
3425
3426 /* Describe LSA Header from Database Summary List. */
3427 lsdb = &nbr->db_sum;
3428
3429 for (i = OSPF_MIN_LSA; i < OSPF_MAX_LSA; i++) {
3430 struct route_table *table = lsdb->type[i].db;
3431 struct route_node *rn;
3432
3433 for (rn = route_top(table); rn; rn = route_next(rn))
3434 if ((lsa = rn->info) != NULL) {
3435 if (IS_OPAQUE_LSA(lsa->data->type)
3436 && (!CHECK_FLAG(options, OSPF_OPTION_O))) {
3437 /* Suppress advertising
3438 * opaque-information. */
3439 /* Remove LSA from DB summary list. */
3440 ospf_lsdb_delete(lsdb, lsa);
3441 continue;
3442 }
3443
3444 if (!CHECK_FLAG(lsa->flags, OSPF_LSA_DISCARD)) {
3445 struct lsa_header *lsah;
3446 uint16_t ls_age;
3447
3448 /* DD packet overflows interface MTU. */
3449 if (length + OSPF_LSA_HEADER_SIZE
3450 > ospf_packet_max(oi))
3451 break;
3452
3453 /* Keep pointer to LS age. */
3454 lsah = (struct lsa_header
3455 *)(STREAM_DATA(s)
3456 + stream_get_endp(
3457 s));
3458
3459 /* Proceed stream pointer. */
3460 stream_put(s, lsa->data,
3461 OSPF_LSA_HEADER_SIZE);
3462 length += OSPF_LSA_HEADER_SIZE;
3463
3464 /* Set LS age. */
3465 ls_age = LS_AGE(lsa);
3466 lsah->ls_age = htons(ls_age);
3467 }
3468
3469 /* Remove LSA from DB summary list. */
3470 ospf_lsdb_delete(lsdb, lsa);
3471 }
3472 }
3473
3474 /* Update 'More' bit */
3475 if (ospf_db_summary_isempty(nbr)) {
3476 empty:
3477 if (nbr->state >= NSM_Exchange) {
3478 UNSET_FLAG(nbr->dd_flags, OSPF_DD_FLAG_M);
3479 /* Rewrite DD flags */
3480 stream_putc_at(s, pp, nbr->dd_flags);
3481 } else {
3482 assert(IS_SET_DD_M(nbr->dd_flags));
3483 }
3484 }
3485 return length;
3486 }
3487
3488 static int ospf_make_ls_req_func(struct stream *s, uint16_t *length,
3489 unsigned long delta, struct ospf_neighbor *nbr,
3490 struct ospf_lsa *lsa)
3491 {
3492 struct ospf_interface *oi;
3493
3494 oi = nbr->oi;
3495
3496 /* LS Request packet overflows interface MTU
3497 * delta is just number of bytes required for 1 LS Req
3498 * ospf_packet_max will return the number of bytes can
3499 * be accomodated without ospf header. So length+delta
3500 * can be compared to ospf_packet_max
3501 * to check if it can fit another lsreq in the same packet.
3502 */
3503
3504 if (*length + delta > ospf_packet_max(oi))
3505 return 0;
3506
3507 stream_putl(s, lsa->data->type);
3508 stream_put_ipv4(s, lsa->data->id.s_addr);
3509 stream_put_ipv4(s, lsa->data->adv_router.s_addr);
3510
3511 ospf_lsa_unlock(&nbr->ls_req_last);
3512 nbr->ls_req_last = ospf_lsa_lock(lsa);
3513
3514 *length += 12;
3515 return 1;
3516 }
3517
3518 static int ospf_make_ls_req(struct ospf_neighbor *nbr, struct stream *s)
3519 {
3520 struct ospf_lsa *lsa;
3521 uint16_t length = OSPF_LS_REQ_MIN_SIZE;
3522 unsigned long delta = 12;
3523 struct route_table *table;
3524 struct route_node *rn;
3525 int i;
3526 struct ospf_lsdb *lsdb;
3527
3528 lsdb = &nbr->ls_req;
3529
3530 for (i = OSPF_MIN_LSA; i < OSPF_MAX_LSA; i++) {
3531 table = lsdb->type[i].db;
3532 for (rn = route_top(table); rn; rn = route_next(rn))
3533 if ((lsa = (rn->info)) != NULL)
3534 if (ospf_make_ls_req_func(s, &length, delta,
3535 nbr, lsa)
3536 == 0) {
3537 route_unlock_node(rn);
3538 break;
3539 }
3540 }
3541 return length;
3542 }
3543
3544 static int ls_age_increment(struct ospf_lsa *lsa, int delay)
3545 {
3546 int age;
3547
3548 age = IS_LSA_MAXAGE(lsa) ? OSPF_LSA_MAXAGE : LS_AGE(lsa) + delay;
3549
3550 return (age > OSPF_LSA_MAXAGE ? OSPF_LSA_MAXAGE : age);
3551 }
3552
3553 static int ospf_make_ls_upd(struct ospf_interface *oi, struct list *update,
3554 struct stream *s)
3555 {
3556 struct ospf_lsa *lsa;
3557 struct listnode *node;
3558 uint16_t length = 0;
3559 unsigned int size_noauth;
3560 unsigned long delta = stream_get_endp(s);
3561 unsigned long pp;
3562 int count = 0;
3563
3564 if (IS_DEBUG_OSPF_EVENT)
3565 zlog_debug("ospf_make_ls_upd: Start");
3566
3567 pp = stream_get_endp(s);
3568 stream_forward_endp(s, OSPF_LS_UPD_MIN_SIZE);
3569 length += OSPF_LS_UPD_MIN_SIZE;
3570
3571 /* Calculate amount of packet usable for data. */
3572 size_noauth = stream_get_size(s) - ospf_packet_authspace(oi);
3573
3574 while ((node = listhead(update)) != NULL) {
3575 struct lsa_header *lsah;
3576 uint16_t ls_age;
3577
3578 lsa = listgetdata(node);
3579 assert(lsa->data);
3580
3581 if (IS_DEBUG_OSPF_EVENT)
3582 zlog_debug("%s: List Iteration %d LSA[%s]", __func__,
3583 count, dump_lsa_key(lsa));
3584
3585 /* Will it fit? Minimum it has to fit atleast one */
3586 if ((length + delta + ntohs(lsa->data->length) > size_noauth) &&
3587 (count > 0))
3588 break;
3589
3590 /* Keep pointer to LS age. */
3591 lsah = (struct lsa_header *)(STREAM_DATA(s)
3592 + stream_get_endp(s));
3593
3594 /* Put LSA to Link State Request. */
3595 stream_put(s, lsa->data, ntohs(lsa->data->length));
3596
3597 /* Set LS age. */
3598 /* each hop must increment an lsa_age by transmit_delay
3599 of OSPF interface */
3600 ls_age = ls_age_increment(lsa,
3601 OSPF_IF_PARAM(oi, transmit_delay));
3602 lsah->ls_age = htons(ls_age);
3603
3604 length += ntohs(lsa->data->length);
3605 count++;
3606
3607 list_delete_node(update, node);
3608 ospf_lsa_unlock(&lsa); /* oi->ls_upd_queue */
3609 }
3610
3611 /* Now set #LSAs. */
3612 stream_putl_at(s, pp, count);
3613
3614 if (IS_DEBUG_OSPF_EVENT)
3615 zlog_debug("ospf_make_ls_upd: Stop");
3616 return length;
3617 }
3618
3619 static int ospf_make_ls_ack(struct ospf_interface *oi, struct list *ack,
3620 struct stream *s)
3621 {
3622 struct listnode *node, *nnode;
3623 uint16_t length = OSPF_LS_ACK_MIN_SIZE;
3624 unsigned long delta = OSPF_LSA_HEADER_SIZE;
3625 struct ospf_lsa *lsa;
3626
3627 for (ALL_LIST_ELEMENTS(ack, node, nnode, lsa)) {
3628 assert(lsa);
3629
3630 /* LS Ack packet overflows interface MTU
3631 * delta is just number of bytes required for
3632 * 1 LS Ack(1 LS Hdr) ospf_packet_max will return
3633 * the number of bytes can be accomodated without
3634 * ospf header. So length+delta can be compared
3635 * against ospf_packet_max to check if it can fit
3636 * another ls header in the same packet.
3637 */
3638 if ((length + delta) > ospf_packet_max(oi))
3639 break;
3640
3641 stream_put(s, lsa->data, OSPF_LSA_HEADER_SIZE);
3642 length += OSPF_LSA_HEADER_SIZE;
3643
3644 listnode_delete(ack, lsa);
3645 ospf_lsa_unlock(&lsa); /* oi->ls_ack_direct.ls_ack */
3646 }
3647
3648 return length;
3649 }
3650
3651 static void ospf_hello_send_sub(struct ospf_interface *oi, in_addr_t addr)
3652 {
3653 struct ospf_packet *op;
3654 uint16_t length = OSPF_HEADER_SIZE;
3655
3656 op = ospf_packet_new(oi->ifp->mtu);
3657
3658 /* Prepare OSPF common header. */
3659 ospf_make_header(OSPF_MSG_HELLO, oi, op->s);
3660
3661 /* Prepare OSPF Hello body. */
3662 length += ospf_make_hello(oi, op->s);
3663 if (length == OSPF_HEADER_SIZE) {
3664 /* Hello overshooting MTU */
3665 ospf_packet_free(op);
3666 return;
3667 }
3668
3669 /* Fill OSPF header. */
3670 ospf_fill_header(oi, op->s, length);
3671
3672 /* Set packet length. */
3673 op->length = length;
3674
3675 op->dst.s_addr = addr;
3676
3677 if (IS_DEBUG_OSPF_EVENT) {
3678 if (oi->ospf->vrf_id)
3679 zlog_debug(
3680 "%s: Hello Tx interface %s ospf vrf %s id %u",
3681 __func__, oi->ifp->name,
3682 ospf_vrf_id_to_name(oi->ospf->vrf_id),
3683 oi->ospf->vrf_id);
3684 }
3685 /* Add packet to the top of the interface output queue, so that they
3686 * can't get delayed by things like long queues of LS Update packets
3687 */
3688 ospf_packet_add_top(oi, op);
3689
3690 /* Hook thread to write packet. */
3691 OSPF_ISM_WRITE_ON(oi->ospf);
3692 }
3693
3694 static void ospf_poll_send(struct ospf_nbr_nbma *nbr_nbma)
3695 {
3696 struct ospf_interface *oi;
3697
3698 oi = nbr_nbma->oi;
3699 assert(oi);
3700
3701 /* If this is passive interface, do not send OSPF Hello. */
3702 if (OSPF_IF_PASSIVE_STATUS(oi) == OSPF_IF_PASSIVE)
3703 return;
3704
3705 if (oi->type != OSPF_IFTYPE_NBMA)
3706 return;
3707
3708 if (nbr_nbma->nbr != NULL && nbr_nbma->nbr->state != NSM_Down)
3709 return;
3710
3711 if (PRIORITY(oi) == 0)
3712 return;
3713
3714 if (nbr_nbma->priority == 0 && oi->state != ISM_DR
3715 && oi->state != ISM_Backup)
3716 return;
3717
3718 ospf_hello_send_sub(oi, nbr_nbma->addr.s_addr);
3719 }
3720
3721 int ospf_poll_timer(struct thread *thread)
3722 {
3723 struct ospf_nbr_nbma *nbr_nbma;
3724
3725 nbr_nbma = THREAD_ARG(thread);
3726 nbr_nbma->t_poll = NULL;
3727
3728 if (IS_DEBUG_OSPF(nsm, NSM_TIMERS))
3729 zlog_debug("NSM[%s:%pI4]: Timer (Poll timer expire)",
3730 IF_NAME(nbr_nbma->oi), &nbr_nbma->addr);
3731
3732 ospf_poll_send(nbr_nbma);
3733
3734 if (nbr_nbma->v_poll > 0)
3735 OSPF_POLL_TIMER_ON(nbr_nbma->t_poll, ospf_poll_timer,
3736 nbr_nbma->v_poll);
3737
3738 return 0;
3739 }
3740
3741
3742 int ospf_hello_reply_timer(struct thread *thread)
3743 {
3744 struct ospf_neighbor *nbr;
3745
3746 nbr = THREAD_ARG(thread);
3747 nbr->t_hello_reply = NULL;
3748
3749 if (IS_DEBUG_OSPF(nsm, NSM_TIMERS))
3750 zlog_debug("NSM[%s:%pI4]: Timer (hello-reply timer expire)",
3751 IF_NAME(nbr->oi), &nbr->router_id);
3752
3753 ospf_hello_send_sub(nbr->oi, nbr->address.u.prefix4.s_addr);
3754
3755 return 0;
3756 }
3757
3758 /* Send OSPF Hello. */
3759 void ospf_hello_send(struct ospf_interface *oi)
3760 {
3761 /* If this is passive interface, do not send OSPF Hello. */
3762 if (OSPF_IF_PASSIVE_STATUS(oi) == OSPF_IF_PASSIVE)
3763 return;
3764
3765 if (oi->type == OSPF_IFTYPE_NBMA) {
3766 struct ospf_neighbor *nbr;
3767 struct route_node *rn;
3768
3769 for (rn = route_top(oi->nbrs); rn; rn = route_next(rn))
3770 if ((nbr = rn->info))
3771 if (nbr != oi->nbr_self)
3772 if (nbr->state != NSM_Down) {
3773 /* RFC 2328 Section 9.5.1
3774 If the router is not
3775 eligible to become Designated
3776 Router,
3777 it must periodically send
3778 Hello Packets to both the
3779 Designated Router and the
3780 Backup Designated Router (if
3781 they
3782 exist). */
3783 if (PRIORITY(oi) == 0
3784 && IPV4_ADDR_CMP(
3785 &DR(oi),
3786 &nbr->address.u
3787 .prefix4)
3788 && IPV4_ADDR_CMP(
3789 &BDR(oi),
3790 &nbr->address.u
3791 .prefix4))
3792 continue;
3793
3794 /* If the router is eligible to
3795 become Designated Router, it
3796 must periodically send Hello
3797 Packets to all neighbors that
3798 are also eligible. In
3799 addition, if the router is
3800 itself the
3801 Designated Router or Backup
3802 Designated Router, it must
3803 also
3804 send periodic Hello Packets
3805 to all other neighbors. */
3806
3807 if (nbr->priority == 0
3808 && oi->state == ISM_DROther)
3809 continue;
3810 /* if oi->state == Waiting, send
3811 * hello to all neighbors */
3812 ospf_hello_send_sub(
3813 oi,
3814 nbr->address.u.prefix4
3815 .s_addr);
3816 }
3817 } else {
3818 /* Decide destination address. */
3819 if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
3820 ospf_hello_send_sub(oi, oi->vl_data->peer_addr.s_addr);
3821 else
3822 ospf_hello_send_sub(oi, htonl(OSPF_ALLSPFROUTERS));
3823 }
3824 }
3825
3826 /* Send OSPF Database Description. */
3827 void ospf_db_desc_send(struct ospf_neighbor *nbr)
3828 {
3829 struct ospf_interface *oi;
3830 struct ospf_packet *op;
3831 uint16_t length = OSPF_HEADER_SIZE;
3832
3833 oi = nbr->oi;
3834 op = ospf_packet_new(oi->ifp->mtu);
3835
3836 /* Prepare OSPF common header. */
3837 ospf_make_header(OSPF_MSG_DB_DESC, oi, op->s);
3838
3839 /* Prepare OSPF Database Description body. */
3840 length += ospf_make_db_desc(oi, nbr, op->s);
3841
3842 /* Fill OSPF header. */
3843 ospf_fill_header(oi, op->s, length);
3844
3845 /* Set packet length. */
3846 op->length = length;
3847
3848 /* Decide destination address. */
3849 if (oi->type == OSPF_IFTYPE_POINTOPOINT)
3850 op->dst.s_addr = htonl(OSPF_ALLSPFROUTERS);
3851 else
3852 op->dst = nbr->address.u.prefix4;
3853
3854 /* Add packet to the interface output queue. */
3855 ospf_packet_add(oi, op);
3856
3857 /* Hook thread to write packet. */
3858 OSPF_ISM_WRITE_ON(oi->ospf);
3859
3860 /* Remove old DD packet, then copy new one and keep in neighbor
3861 * structure. */
3862 if (nbr->last_send)
3863 ospf_packet_free(nbr->last_send);
3864 nbr->last_send = ospf_packet_dup(op);
3865 monotime(&nbr->last_send_ts);
3866 if (CHECK_FLAG(oi->ospf->config, OSPF_LOG_ADJACENCY_DETAIL))
3867 zlog_info(
3868 "%s:Packet[DD]: %pI4 DB Desc send with seqnum:%x , flags:%x",
3869 (oi->ospf->name) ? oi->ospf->name : VRF_DEFAULT_NAME,
3870 &nbr->router_id, nbr->dd_seqnum,
3871 nbr->dd_flags);
3872 }
3873
3874 /* Re-send Database Description. */
3875 void ospf_db_desc_resend(struct ospf_neighbor *nbr)
3876 {
3877 struct ospf_interface *oi;
3878
3879 oi = nbr->oi;
3880
3881 /* Add packet to the interface output queue. */
3882 ospf_packet_add(oi, ospf_packet_dup(nbr->last_send));
3883
3884 /* Hook thread to write packet. */
3885 OSPF_ISM_WRITE_ON(oi->ospf);
3886 if (CHECK_FLAG(oi->ospf->config, OSPF_LOG_ADJACENCY_DETAIL))
3887 zlog_info(
3888 "%s:Packet[DD]: %pI4 DB Desc resend with seqnum:%x , flags:%x",
3889 (oi->ospf->name) ? oi->ospf->name : VRF_DEFAULT_NAME,
3890 &nbr->router_id, nbr->dd_seqnum,
3891 nbr->dd_flags);
3892 }
3893
3894 /* Send Link State Request. */
3895 void ospf_ls_req_send(struct ospf_neighbor *nbr)
3896 {
3897 struct ospf_interface *oi;
3898 struct ospf_packet *op;
3899 uint16_t length = OSPF_HEADER_SIZE;
3900
3901 oi = nbr->oi;
3902 op = ospf_packet_new(oi->ifp->mtu);
3903
3904 /* Prepare OSPF common header. */
3905 ospf_make_header(OSPF_MSG_LS_REQ, oi, op->s);
3906
3907 /* Prepare OSPF Link State Request body. */
3908 length += ospf_make_ls_req(nbr, op->s);
3909 if (length == OSPF_HEADER_SIZE) {
3910 ospf_packet_free(op);
3911 return;
3912 }
3913
3914 /* Fill OSPF header. */
3915 ospf_fill_header(oi, op->s, length);
3916
3917 /* Set packet length. */
3918 op->length = length;
3919
3920 /* Decide destination address. */
3921 if (oi->type == OSPF_IFTYPE_POINTOPOINT)
3922 op->dst.s_addr = htonl(OSPF_ALLSPFROUTERS);
3923 else
3924 op->dst = nbr->address.u.prefix4;
3925
3926 /* Add packet to the interface output queue. */
3927 ospf_packet_add(oi, op);
3928
3929 /* Hook thread to write packet. */
3930 OSPF_ISM_WRITE_ON(oi->ospf);
3931
3932 /* Add Link State Request Retransmission Timer. */
3933 OSPF_NSM_TIMER_ON(nbr->t_ls_req, ospf_ls_req_timer, nbr->v_ls_req);
3934 }
3935
3936 /* Send Link State Update with an LSA. */
3937 void ospf_ls_upd_send_lsa(struct ospf_neighbor *nbr, struct ospf_lsa *lsa,
3938 int flag)
3939 {
3940 struct list *update;
3941
3942 update = list_new();
3943
3944 listnode_add(update, lsa);
3945
3946 /*ospf instance is going down, send self originated
3947 * MAXAGE LSA update to neighbors to remove from LSDB */
3948 if (nbr->oi->ospf->inst_shutdown && IS_LSA_MAXAGE(lsa))
3949 ospf_ls_upd_send(nbr, update, flag, 1);
3950 else
3951 ospf_ls_upd_send(nbr, update, flag, 0);
3952
3953 list_delete(&update);
3954 }
3955
3956 /* Determine size for packet. Must be at least big enough to accomodate next
3957 * LSA on list, which may be bigger than MTU size.
3958 *
3959 * Return pointer to new ospf_packet
3960 * NULL if we can not allocate, eg because LSA is bigger than imposed limit
3961 * on packet sizes (in which case offending LSA is deleted from update list)
3962 */
3963 static struct ospf_packet *ospf_ls_upd_packet_new(struct list *update,
3964 struct ospf_interface *oi)
3965 {
3966 struct ospf_lsa *lsa;
3967 struct listnode *ln;
3968 size_t size;
3969 static char warned = 0;
3970
3971 lsa = listgetdata((ln = listhead(update)));
3972 assert(lsa->data);
3973
3974 if ((OSPF_LS_UPD_MIN_SIZE + ntohs(lsa->data->length))
3975 > ospf_packet_max(oi)) {
3976 if (!warned) {
3977 flog_warn(
3978 EC_OSPF_LARGE_LSA,
3979 "ospf_ls_upd_packet_new: oversized LSA encountered!will need to fragment. Not optimal. Try divide up your network with areas. Use 'debug ospf packet send' to see details, or look at 'show ip ospf database ..'");
3980 warned = 1;
3981 }
3982
3983 if (IS_DEBUG_OSPF_PACKET(0, SEND))
3984 zlog_debug(
3985 "ospf_ls_upd_packet_new: oversized LSA id:%pI4, %d bytes originated by %pI4, will be fragmented!",
3986 &lsa->data->id,
3987 ntohs(lsa->data->length),
3988 &lsa->data->adv_router);
3989
3990 /*
3991 * Allocate just enough to fit this LSA only, to avoid including
3992 * other
3993 * LSAs in fragmented LSA Updates.
3994 */
3995 size = ntohs(lsa->data->length)
3996 + (oi->ifp->mtu - ospf_packet_max(oi))
3997 + OSPF_LS_UPD_MIN_SIZE;
3998 } else
3999 size = oi->ifp->mtu;
4000
4001 if (size > OSPF_MAX_PACKET_SIZE) {
4002 flog_warn(EC_OSPF_LARGE_LSA,
4003 "ospf_ls_upd_packet_new: oversized LSA id:%pI4 too big, %d bytes, packet size %ld, dropping it completely. OSPF routing is broken!",
4004 &lsa->data->id, ntohs(lsa->data->length),
4005 (long int)size);
4006 list_delete_node(update, ln);
4007 return NULL;
4008 }
4009
4010 /* IP header is built up separately by ospf_write(). This means, that we
4011 * must
4012 * reduce the "affordable" size just calculated by length of an IP
4013 * header.
4014 * This makes sure, that even if we manage to fill the payload with LSA
4015 * data
4016 * completely, the final packet (our data plus IP header) still fits
4017 * into
4018 * outgoing interface MTU. This correction isn't really meaningful for
4019 * an
4020 * oversized LSA, but for consistency the correction is done for both
4021 * cases.
4022 *
4023 * P.S. OSPF_MAX_PACKET_SIZE above already includes IP header size
4024 */
4025 return ospf_packet_new(size - sizeof(struct ip));
4026 }
4027
4028 static void ospf_ls_upd_queue_send(struct ospf_interface *oi,
4029 struct list *update, struct in_addr addr,
4030 int send_lsupd_now)
4031 {
4032 struct ospf_packet *op;
4033 uint16_t length = OSPF_HEADER_SIZE;
4034
4035 if (IS_DEBUG_OSPF_EVENT)
4036 zlog_debug("listcount = %d, [%s]dst %pI4", listcount(update),
4037 IF_NAME(oi), &addr);
4038
4039 /* Check that we have really something to process */
4040 if (listcount(update) == 0)
4041 return;
4042
4043 op = ospf_ls_upd_packet_new(update, oi);
4044
4045 /* Prepare OSPF common header. */
4046 ospf_make_header(OSPF_MSG_LS_UPD, oi, op->s);
4047
4048 /* Prepare OSPF Link State Update body.
4049 * Includes Type-7 translation.
4050 */
4051 length += ospf_make_ls_upd(oi, update, op->s);
4052
4053 /* Fill OSPF header. */
4054 ospf_fill_header(oi, op->s, length);
4055
4056 /* Set packet length. */
4057 op->length = length;
4058
4059 /* Decide destination address. */
4060 if (oi->type == OSPF_IFTYPE_POINTOPOINT)
4061 op->dst.s_addr = htonl(OSPF_ALLSPFROUTERS);
4062 else
4063 op->dst.s_addr = addr.s_addr;
4064
4065 /* Add packet to the interface output queue. */
4066 ospf_packet_add(oi, op);
4067 /* Call ospf_write() right away to send ospf packets to neighbors */
4068 if (send_lsupd_now) {
4069 struct thread os_packet_thd;
4070
4071 os_packet_thd.arg = (void *)oi->ospf;
4072 if (oi->on_write_q == 0) {
4073 listnode_add(oi->ospf->oi_write_q, oi);
4074 oi->on_write_q = 1;
4075 }
4076 ospf_write(&os_packet_thd);
4077 /*
4078 * We are fake calling ospf_write with a fake
4079 * thread. Imagine that we have oi_a already
4080 * enqueued and we have turned on the write
4081 * thread(t_write).
4082 * Now this function calls this for oi_b
4083 * so the on_write_q has oi_a and oi_b on
4084 * it, ospf_write runs and clears the packets
4085 * for both oi_a and oi_b. Removing them from
4086 * the on_write_q. After this thread of execution
4087 * finishes we will execute the t_write thread
4088 * with nothing in the on_write_q causing an
4089 * assert. So just make sure that the t_write
4090 * is actually turned off.
4091 */
4092 if (list_isempty(oi->ospf->oi_write_q))
4093 OSPF_TIMER_OFF(oi->ospf->t_write);
4094 } else {
4095 /* Hook thread to write packet. */
4096 OSPF_ISM_WRITE_ON(oi->ospf);
4097 }
4098 }
4099
4100 static int ospf_ls_upd_send_queue_event(struct thread *thread)
4101 {
4102 struct ospf_interface *oi = THREAD_ARG(thread);
4103 struct route_node *rn;
4104 struct route_node *rnext;
4105 struct list *update;
4106 char again = 0;
4107
4108 oi->t_ls_upd_event = NULL;
4109
4110 if (IS_DEBUG_OSPF_EVENT)
4111 zlog_debug("ospf_ls_upd_send_queue start");
4112
4113 for (rn = route_top(oi->ls_upd_queue); rn; rn = rnext) {
4114 rnext = route_next(rn);
4115
4116 if (rn->info == NULL)
4117 continue;
4118
4119 update = (struct list *)rn->info;
4120
4121 ospf_ls_upd_queue_send(oi, update, rn->p.u.prefix4, 0);
4122
4123 /* list might not be empty. */
4124 if (listcount(update) == 0) {
4125 list_delete((struct list **)&rn->info);
4126 route_unlock_node(rn);
4127 } else
4128 again = 1;
4129 }
4130
4131 if (again != 0) {
4132 if (IS_DEBUG_OSPF_EVENT)
4133 zlog_debug(
4134 "ospf_ls_upd_send_queue: update lists not cleared, %d nodes to try again, raising new event",
4135 again);
4136 oi->t_ls_upd_event = NULL;
4137 thread_add_event(master, ospf_ls_upd_send_queue_event, oi, 0,
4138 &oi->t_ls_upd_event);
4139 }
4140
4141 if (IS_DEBUG_OSPF_EVENT)
4142 zlog_debug("ospf_ls_upd_send_queue stop");
4143
4144 return 0;
4145 }
4146
4147 void ospf_ls_upd_send(struct ospf_neighbor *nbr, struct list *update, int flag,
4148 int send_lsupd_now)
4149 {
4150 struct ospf_interface *oi;
4151 struct ospf_lsa *lsa;
4152 struct prefix_ipv4 p;
4153 struct route_node *rn;
4154 struct listnode *node;
4155
4156 oi = nbr->oi;
4157
4158 p.family = AF_INET;
4159 p.prefixlen = IPV4_MAX_BITLEN;
4160
4161 /* Decide destination address. */
4162 if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
4163 p.prefix = oi->vl_data->peer_addr;
4164 else if (oi->type == OSPF_IFTYPE_POINTOPOINT)
4165 p.prefix.s_addr = htonl(OSPF_ALLSPFROUTERS);
4166 else if (flag == OSPF_SEND_PACKET_DIRECT)
4167 p.prefix = nbr->address.u.prefix4;
4168 else if (oi->state == ISM_DR || oi->state == ISM_Backup)
4169 p.prefix.s_addr = htonl(OSPF_ALLSPFROUTERS);
4170 else if (oi->type == OSPF_IFTYPE_POINTOMULTIPOINT)
4171 p.prefix.s_addr = htonl(OSPF_ALLSPFROUTERS);
4172 else
4173 p.prefix.s_addr = htonl(OSPF_ALLDROUTERS);
4174
4175 if (oi->type == OSPF_IFTYPE_NBMA) {
4176 if (flag == OSPF_SEND_PACKET_INDIRECT)
4177 flog_warn(
4178 EC_OSPF_PACKET,
4179 "* LS-Update is directly sent on NBMA network.");
4180 if (IPV4_ADDR_SAME(&oi->address->u.prefix4, &p.prefix))
4181 flog_warn(EC_OSPF_PACKET,
4182 "* LS-Update is sent to myself.");
4183 }
4184
4185 rn = route_node_get(oi->ls_upd_queue, (struct prefix *)&p);
4186
4187 if (rn->info == NULL)
4188 rn->info = list_new();
4189 else
4190 route_unlock_node(rn);
4191
4192 for (ALL_LIST_ELEMENTS_RO(update, node, lsa))
4193 listnode_add(rn->info,
4194 ospf_lsa_lock(lsa)); /* oi->ls_upd_queue */
4195 if (send_lsupd_now) {
4196 struct list *send_update_list;
4197 struct route_node *rnext;
4198
4199 for (rn = route_top(oi->ls_upd_queue); rn; rn = rnext) {
4200 rnext = route_next(rn);
4201
4202 if (rn->info == NULL)
4203 continue;
4204
4205 send_update_list = (struct list *)rn->info;
4206
4207 ospf_ls_upd_queue_send(oi, send_update_list,
4208 rn->p.u.prefix4, 1);
4209 }
4210 } else
4211 thread_add_event(master, ospf_ls_upd_send_queue_event, oi, 0,
4212 &oi->t_ls_upd_event);
4213 }
4214
4215 static void ospf_ls_ack_send_list(struct ospf_interface *oi, struct list *ack,
4216 struct in_addr dst)
4217 {
4218 struct ospf_packet *op;
4219 uint16_t length = OSPF_HEADER_SIZE;
4220
4221 op = ospf_packet_new(oi->ifp->mtu);
4222
4223 /* Prepare OSPF common header. */
4224 ospf_make_header(OSPF_MSG_LS_ACK, oi, op->s);
4225
4226 /* Prepare OSPF Link State Acknowledgment body. */
4227 length += ospf_make_ls_ack(oi, ack, op->s);
4228
4229 /* Fill OSPF header. */
4230 ospf_fill_header(oi, op->s, length);
4231
4232 /* Set packet length. */
4233 op->length = length;
4234
4235 /* Decide destination address. */
4236 if (oi->type == OSPF_IFTYPE_POINTOPOINT)
4237 op->dst.s_addr = htonl(OSPF_ALLSPFROUTERS);
4238 else
4239 op->dst.s_addr = dst.s_addr;
4240
4241 /* Add packet to the interface output queue. */
4242 ospf_packet_add(oi, op);
4243
4244 /* Hook thread to write packet. */
4245 OSPF_ISM_WRITE_ON(oi->ospf);
4246 }
4247
4248 static int ospf_ls_ack_send_event(struct thread *thread)
4249 {
4250 struct ospf_interface *oi = THREAD_ARG(thread);
4251
4252 oi->t_ls_ack_direct = NULL;
4253
4254 while (listcount(oi->ls_ack_direct.ls_ack))
4255 ospf_ls_ack_send_list(oi, oi->ls_ack_direct.ls_ack,
4256 oi->ls_ack_direct.dst);
4257
4258 return 0;
4259 }
4260
4261 void ospf_ls_ack_send(struct ospf_neighbor *nbr, struct ospf_lsa *lsa)
4262 {
4263 struct ospf_interface *oi = nbr->oi;
4264
4265 if (IS_GRACE_LSA(lsa)) {
4266 if (IS_DEBUG_OSPF_GR_HELPER)
4267 zlog_debug("%s, Sending GRACE ACK to Restarter.",
4268 __func__);
4269 }
4270
4271 if (listcount(oi->ls_ack_direct.ls_ack) == 0)
4272 oi->ls_ack_direct.dst = nbr->address.u.prefix4;
4273
4274 listnode_add(oi->ls_ack_direct.ls_ack, ospf_lsa_lock(lsa));
4275
4276 thread_add_event(master, ospf_ls_ack_send_event, oi, 0,
4277 &oi->t_ls_ack_direct);
4278 }
4279
4280 /* Send Link State Acknowledgment delayed. */
4281 void ospf_ls_ack_send_delayed(struct ospf_interface *oi)
4282 {
4283 struct in_addr dst;
4284
4285 /* Decide destination address. */
4286 /* RFC2328 Section 13.5 On non-broadcast
4287 networks, delayed Link State Acknowledgment packets must be
4288 unicast separately over each adjacency (i.e., neighbor whose
4289 state is >= Exchange). */
4290 if (oi->type == OSPF_IFTYPE_NBMA) {
4291 struct ospf_neighbor *nbr;
4292 struct route_node *rn;
4293
4294 for (rn = route_top(oi->nbrs); rn; rn = route_next(rn))
4295 if ((nbr = rn->info) != NULL)
4296 if (nbr != oi->nbr_self
4297 && nbr->state >= NSM_Exchange)
4298 while (listcount(oi->ls_ack))
4299 ospf_ls_ack_send_list(
4300 oi, oi->ls_ack,
4301 nbr->address.u.prefix4);
4302 return;
4303 }
4304 if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
4305 dst.s_addr = oi->vl_data->peer_addr.s_addr;
4306 else if (oi->state == ISM_DR || oi->state == ISM_Backup)
4307 dst.s_addr = htonl(OSPF_ALLSPFROUTERS);
4308 else if (oi->type == OSPF_IFTYPE_POINTOPOINT)
4309 dst.s_addr = htonl(OSPF_ALLSPFROUTERS);
4310 else if (oi->type == OSPF_IFTYPE_POINTOMULTIPOINT)
4311 dst.s_addr = htonl(OSPF_ALLSPFROUTERS);
4312 else
4313 dst.s_addr = htonl(OSPF_ALLDROUTERS);
4314
4315 while (listcount(oi->ls_ack))
4316 ospf_ls_ack_send_list(oi, oi->ls_ack, dst);
4317 }
4318
4319 /*
4320 * On pt-to-pt links, all OSPF control packets are sent to the multicast
4321 * address. As a result, the kernel does not need to learn the interface
4322 * MAC of the OSPF neighbor. However, in our world, this will delay
4323 * convergence. Take the case when due to a link flap, all routes now
4324 * want to use an interface which was deemed to be costlier prior to this
4325 * event. For routes that will be installed, the missing MAC will have
4326 * punt-to-CPU set on them. This may overload the CPU control path that
4327 * can be avoided if the MAC was known apriori.
4328 */
4329 void ospf_proactively_arp(struct ospf_neighbor *nbr)
4330 {
4331 if (!nbr || !nbr->oi->ospf->proactive_arp)
4332 return;
4333
4334 ospf_zebra_send_arp(nbr->oi->ifp, &nbr->address);
4335 }
FRRouting mirror