2 * OSPF Sending and Receiving OSPF Packets.
3 * Copyright (C) 1999, 2000 Toshiaki Takada
5 * This file is part of GNU Zebra.
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
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.
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
31 #include "sockunion.h"
36 #ifdef CRYPTO_INTERNAL
40 #include "lib_errors.h"
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.h"
60 * OSPF Fragmentation / fragmented writes
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.
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
76 #define WANT_OSPF_WRITE_FRAGMENT
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"},
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
[] = {
93 OSPF_DB_DESC_MIN_SIZE
,
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
[] = {
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
,
109 OSPF_AS_EXTERNAL_LSA_MIN_SIZE
,
116 /* for ospf_check_auth() */
117 static int ospf_check_sum(struct ospf_header
*);
119 /* OSPF authentication checking function */
120 static int ospf_auth_type(struct ospf_interface
*oi
)
124 if (OSPF_IF_PARAM(oi
, auth_type
) == OSPF_AUTH_NOTSET
)
125 auth_type
= oi
->area
->auth_type
;
127 auth_type
= OSPF_IF_PARAM(oi
, auth_type
);
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
;
137 static struct ospf_packet
*ospf_packet_new(size_t size
)
139 struct ospf_packet
*new;
141 new = XCALLOC(MTYPE_OSPF_PACKET
, sizeof(struct ospf_packet
));
142 new->s
= stream_new(size
);
147 void ospf_packet_free(struct ospf_packet
*op
)
152 XFREE(MTYPE_OSPF_PACKET
, op
);
155 struct ospf_fifo
*ospf_fifo_new(void)
157 struct ospf_fifo
*new;
159 new = XCALLOC(MTYPE_OSPF_FIFO
, sizeof(struct ospf_fifo
));
163 /* Add new packet to fifo. */
164 void ospf_fifo_push(struct ospf_fifo
*fifo
, struct ospf_packet
*op
)
167 fifo
->tail
->next
= op
;
176 /* Add new packet to head of fifo. */
177 static void ospf_fifo_push_head(struct ospf_fifo
*fifo
, struct ospf_packet
*op
)
179 op
->next
= fifo
->head
;
181 if (fifo
->tail
== NULL
)
189 /* Delete first packet from fifo. */
190 struct ospf_packet
*ospf_fifo_pop(struct ospf_fifo
*fifo
)
192 struct ospf_packet
*op
;
197 fifo
->head
= op
->next
;
199 if (fifo
->head
== NULL
)
208 /* Return first fifo entry. */
209 struct ospf_packet
*ospf_fifo_head(struct ospf_fifo
*fifo
)
214 /* Flush ospf packet fifo. */
215 void ospf_fifo_flush(struct ospf_fifo
*fifo
)
217 struct ospf_packet
*op
;
218 struct ospf_packet
*next
;
220 for (op
= fifo
->head
; op
; op
= next
) {
222 ospf_packet_free(op
);
224 fifo
->head
= fifo
->tail
= NULL
;
228 /* Free ospf packet fifo. */
229 void ospf_fifo_free(struct ospf_fifo
*fifo
)
231 ospf_fifo_flush(fifo
);
233 XFREE(MTYPE_OSPF_FIFO
, fifo
);
236 static void ospf_packet_add(struct ospf_interface
*oi
, struct ospf_packet
*op
)
238 /* Add packet to end of queue. */
239 ospf_fifo_push(oi
->obuf
, op
);
241 /* Debug of packet fifo*/
242 /* ospf_fifo_debug (oi->obuf); */
245 static void ospf_packet_add_top(struct ospf_interface
*oi
,
246 struct ospf_packet
*op
)
248 /* Add packet to head of queue. */
249 ospf_fifo_push_head(oi
->obuf
, op
);
251 /* Debug of packet fifo*/
252 /* ospf_fifo_debug (oi->obuf); */
255 static void ospf_packet_delete(struct ospf_interface
*oi
)
257 struct ospf_packet
*op
;
259 op
= ospf_fifo_pop(oi
->obuf
);
262 ospf_packet_free(op
);
265 static struct ospf_packet
*ospf_packet_dup(struct ospf_packet
*op
)
267 struct ospf_packet
*new;
269 if (stream_get_endp(op
->s
) != op
->length
)
272 "ospf_packet_dup stream %lu ospf_packet %u size mismatch",
273 (unsigned long)STREAM_SIZE(op
->s
), op
->length
);
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
);
280 new->length
= op
->length
;
286 static unsigned int ospf_packet_authspace(struct ospf_interface
*oi
)
290 if (ospf_auth_type(oi
) == OSPF_AUTH_CRYPTOGRAPHIC
)
291 auth
= OSPF_AUTH_MD5_SIZE
;
296 static unsigned int ospf_packet_max(struct ospf_interface
*oi
)
300 max
= oi
->ifp
->mtu
- ospf_packet_authspace(oi
);
302 max
-= (OSPF_HEADER_SIZE
+ sizeof(struct ip
));
308 static int ospf_check_md5_digest(struct ospf_interface
*oi
,
309 struct ospf_header
*ospfh
)
311 #ifdef CRYPTO_OPENSSL
313 #elif CRYPTO_INTERNAL
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
);
321 /* Get secret key. */
322 ck
= ospf_crypt_key_lookup(OSPF_IF_PARAM(oi
, auth_crypt
),
323 ospfh
->u
.crypt
.key_id
);
325 flog_warn(EC_OSPF_MD5
, "interface %s: ospf_check_md5 no key %d",
326 IF_NAME(oi
), ospfh
->u
.crypt
.key_id
);
330 /* check crypto seqnum. */
331 nbr
= ospf_nbr_lookup_by_routerid(oi
->nbrs
, &ospfh
->router_id
);
334 && ntohl(nbr
->crypt_seqnum
) > ntohl(ospfh
->u
.crypt
.crypt_seqnum
)) {
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
));
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
));
355 MD5Update(&ctx
, ospfh
, length
);
356 MD5Update(&ctx
, ck
->auth_key
, OSPF_AUTH_MD5_SIZE
);
357 MD5Final(digest
, &ctx
);
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",
368 /* save neighbor's crypt_seqnum */
370 nbr
->crypt_seqnum
= ospfh
->u
.crypt
.crypt_seqnum
;
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
)
380 struct ospf_header
*ospfh
;
381 unsigned char digest
[OSPF_AUTH_MD5_SIZE
] = {0};
382 #ifdef CRYPTO_OPENSSL
384 #elif CRYPTO_INTERNAL
389 struct crypt_key
*ck
;
390 const uint8_t *auth_key
;
392 ibuf
= STREAM_DATA(op
->s
);
393 ospfh
= (struct ospf_header
*)ibuf
;
395 if (ntohs(ospfh
->auth_type
) != OSPF_AUTH_CRYPTOGRAPHIC
)
398 /* We do this here so when we dup a packet, we don't have to
399 waste CPU rewriting other headers.
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
;
408 ospfh
->u
.crypt
.crypt_seqnum
= htonl(oi
->crypt_seqnum
);
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
;
414 ck
= listgetdata(listtail(OSPF_IF_PARAM(oi
, auth_crypt
)));
415 auth_key
= ck
->auth_key
;
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
));
430 MD5Update(&ctx
, ibuf
, ntohs(ospfh
->length
));
431 MD5Update(&ctx
, auth_key
, OSPF_AUTH_MD5_SIZE
);
432 MD5Final(digest
, &ctx
);
435 /* Append md5 digest to the end of the stream. */
436 stream_put(op
->s
, digest
, OSPF_AUTH_MD5_SIZE
);
438 /* We do *NOT* increment the OSPF header length. */
439 op
->length
= ntohs(ospfh
->length
) + OSPF_AUTH_MD5_SIZE
;
441 if (stream_get_endp(op
->s
) != op
->length
)
445 "ospf_make_md5_digest: length mismatch stream %lu ospf_packet %u",
446 (unsigned long)stream_get_endp(op
->s
), op
->length
);
448 return OSPF_AUTH_MD5_SIZE
;
452 static int ospf_ls_req_timer(struct thread
*thread
)
454 struct ospf_neighbor
*nbr
;
456 nbr
= THREAD_ARG(thread
);
457 nbr
->t_ls_req
= NULL
;
459 /* Send Link State Request. */
460 if (ospf_ls_request_count(nbr
))
461 ospf_ls_req_send(nbr
);
463 /* Set Link State Request retransmission timer. */
464 OSPF_NSM_TIMER_ON(nbr
->t_ls_req
, ospf_ls_req_timer
, nbr
->v_ls_req
);
469 void ospf_ls_req_event(struct ospf_neighbor
*nbr
)
471 thread_cancel(&nbr
->t_ls_req
);
472 thread_add_event(master
, ospf_ls_req_timer
, nbr
, 0, &nbr
->t_ls_req
);
475 /* Cyclic timer function. Fist registered in ospf_nbr_new () in
477 int ospf_ls_upd_timer(struct thread
*thread
)
479 struct ospf_neighbor
*nbr
;
481 nbr
= THREAD_ARG(thread
);
482 nbr
->t_ls_upd
= NULL
;
484 /* Send Link State Update. */
485 if (ospf_ls_retransmit_count(nbr
) > 0) {
487 struct ospf_lsdb
*lsdb
;
489 int retransmit_interval
;
491 retransmit_interval
=
492 OSPF_IF_PARAM(nbr
->oi
, retransmit_interval
);
494 lsdb
= &nbr
->ls_rxmt
;
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
;
501 for (rn
= route_top(table
); rn
; rn
= route_next(rn
)) {
502 struct ospf_lsa
*lsa
;
504 if ((lsa
= rn
->info
) != NULL
) {
505 /* Don't retransmit an LSA if we
507 the last RxmtInterval seconds - this
509 neighbour a chance to acknowledge the
511 have ben just received before the
513 fired. This is a small tweak to what
515 but it will cut out out a lot of
518 if (monotime_since(&lsa
->tv_recv
, NULL
)
519 >= retransmit_interval
* 1000000LL)
520 listnode_add(update
, rn
->info
);
525 if (listcount(update
) > 0)
526 ospf_ls_upd_send(nbr
, update
, OSPF_SEND_PACKET_DIRECT
,
528 list_delete(&update
);
531 /* Set LS Update retransmission timer. */
532 OSPF_NSM_TIMER_ON(nbr
->t_ls_upd
, ospf_ls_upd_timer
, nbr
->v_ls_upd
);
537 int ospf_ls_ack_timer(struct thread
*thread
)
539 struct ospf_interface
*oi
;
541 oi
= THREAD_ARG(thread
);
544 /* Send Link State Acknowledgment. */
545 if (listcount(oi
->ls_ack
) > 0)
546 ospf_ls_ack_send_delayed(oi
);
548 /* Set LS Ack timer. */
549 OSPF_ISM_TIMER_ON(oi
->t_ls_ack
, ospf_ls_ack_timer
, oi
->v_ls_ack
);
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
)
559 #define OSPF_WRITE_FRAG_SHIFT 3
564 assert(op
->length
== stream_get_endp(op
->s
));
565 assert(msg
->msg_iovlen
== 2);
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.
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
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.
582 iph
->ip_off
|= IP_MF
;
584 /* ip frag offset is expressed in units of 8byte words */
585 offset
= maxdatasize
>> OSPF_WRITE_FRAG_SHIFT
;
587 iovp
= &msg
->msg_iov
[1];
589 while ((stream_get_endp(op
->s
) - stream_get_getp(op
->s
))
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
);
596 sockopt_iphdrincl_swab_htosys(iph
);
598 ret
= sendmsg(fd
, msg
, flags
);
600 sockopt_iphdrincl_swab_systoh(iph
);
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
));
609 if (IS_DEBUG_OSPF_PACKET(type
- 1, SEND
)) {
611 "ospf_write_frags: sent id %d, off %d, len %d to %pI4",
612 iph
->ip_id
, iph
->ip_off
, iph
->ip_len
,
616 iph
->ip_off
+= offset
;
617 stream_forward_getp(op
->s
, iovp
->iov_len
);
618 iovp
->iov_base
= stream_pnt(op
->s
);
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
);
626 #endif /* WANT_OSPF_WRITE_FRAGMENT */
628 static int ospf_write(struct thread
*thread
)
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
;
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
650 unsigned char cmsgbuf
[64] = {};
651 struct cmsghdr
*cm
= (struct cmsghdr
*)cmsgbuf
;
652 struct in_pktinfo
*pi
;
655 if (ospf
->fd
< 0 || ospf
->oi_running
== 0) {
656 if (IS_DEBUG_OSPF_EVENT
)
658 "ospf_write failed to send, fd %d, instance %u",
659 ospf
->fd
, ospf
->oi_running
);
663 node
= listhead(ospf
->oi_write_q
);
665 oi
= listgetdata(node
);
667 #ifdef WANT_OSPF_WRITE_FRAGMENT
668 /* seed ipid static with low order bits of time */
670 ipid
= (time(NULL
) & 0xffff);
671 #endif /* WANT_OSPF_WRITE_FRAGMENT */
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
;
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
);
688 assert(op
->length
>= OSPF_HEADER_SIZE
);
690 if (op
->dst
.s_addr
== htonl(OSPF_ALLSPFROUTERS
)
691 || op
->dst
.s_addr
== htonl(OSPF_ALLDROUTERS
))
692 ospf_if_ipmulticast(ospf
, oi
->address
,
695 /* Rewrite the md5 signature & update the seq */
696 ospf_make_md5_digest(oi
, op
);
698 /* Retrieve OSPF packet type. */
699 stream_set_getp(op
->s
, 1);
700 type
= stream_getc(op
->s
);
702 /* reset get pointer */
703 stream_set_getp(op
->s
, 0);
705 memset(&iph
, 0, sizeof(struct ip
));
706 memset(&sa_dst
, 0, sizeof(sa_dst
));
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);
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
;
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
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
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
;
732 #if defined(__DragonFly__)
734 * DragonFly's raw socket expects ip_len/ip_off in network byte
737 iph
.ip_len
= htons(iph
.ip_len
);
740 #ifdef WANT_OSPF_WRITE_FRAGMENT
741 /* XXX-MT: not thread-safe at all..
742 * XXX: this presumes this is only programme sending OSPF
744 * otherwise, no guarantee ipid will be unique
747 #endif /* WANT_OSPF_WRITE_FRAGMENT */
750 if (oi
->type
== OSPF_IFTYPE_VIRTUALLINK
)
751 iph
.ip_ttl
= OSPF_VL_IP_TTL
;
753 iph
.ip_ttl
= OSPF_IP_TTL
;
754 iph
.ip_p
= IPPROTO_OSPFIGP
;
756 iph
.ip_src
.s_addr
= oi
->address
->u
.prefix4
.s_addr
;
757 iph
.ip_dst
.s_addr
= op
->dst
.s_addr
;
759 memset(&msg
, 0, sizeof(msg
));
760 msg
.msg_name
= (caddr_t
)&sa_dst
;
761 msg
.msg_namelen
= sizeof(sa_dst
);
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
;
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
;
778 msg
.msg_controllen
= cm
->cmsg_len
;
781 /* Sadly we can not rely on kernels to fragment packets
782 * because of either IP_HDRINCL and/or multicast
783 * destination being set.
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 */
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
)
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
);
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
808 if (ret
< 0 && errno
!= EPERM
)
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
));
816 /* Show debug sending packet. */
817 if (IS_DEBUG_OSPF_PACKET(type
- 1, SEND
)) {
818 if (IS_DEBUG_OSPF_PACKET(type
- 1, DETAIL
)) {
820 "-----------------------------------------------------");
821 stream_set_getp(op
->s
, 0);
822 ospf_packet_dump(op
->s
);
825 zlog_debug("%s sent to [%pI4] via [%s].",
826 lookup_msg(ospf_packet_type_str
, type
, NULL
),
827 &op
->dst
, IF_NAME(oi
));
829 if (IS_DEBUG_OSPF_PACKET(type
- 1, DETAIL
))
831 "-----------------------------------------------------");
838 case OSPF_MSG_DB_DESC
:
841 case OSPF_MSG_LS_REQ
:
844 case OSPF_MSG_LS_UPD
:
847 case OSPF_MSG_LS_ACK
:
854 /* Now delete packet from queue. */
855 ospf_packet_delete(oi
);
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
) {
862 last_serviced_oi
= NULL
;
865 listnode_add(ospf
->oi_write_q
, oi
);
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
);
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
,
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
)
887 struct ospf_hello
*hello
;
888 struct ospf_neighbor
*nbr
;
892 /* increment statistics. */
895 hello
= (struct ospf_hello
*)stream_pnt(s
);
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
)) {
901 "ospf_header[%s/%pI4]: selforiginated, dropping.",
902 lookup_msg(ospf_packet_type_str
, ospfh
->type
,
909 /* get neighbor prefix. */
911 p
.prefixlen
= ip_masklen(hello
->network_mask
);
912 p
.u
.prefix4
= iph
->ip_src
;
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
) {
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
);
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).",
935 OSPF_IF_PARAM(oi
, v_wait
),
936 ntohl(hello
->dead_interval
));
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
)) {
946 "Packet %pI4 [Hello:RECV]: HelloInterval mismatch (expected %u, but received %u).",
948 OSPF_IF_PARAM(oi
, v_hello
),
949 ntohs(hello
->hello_interval
));
954 if (IS_DEBUG_OSPF_EVENT
)
955 zlog_debug("Packet %pI4 [Hello:RECV]: Options %s vrf %s",
957 ospf_options_dump(hello
->options
),
958 ospf_vrf_id_to_name(oi
->ospf
->vrf_id
));
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
)) {
965 * This router does not support non-zero TOS.
966 * Drop this Hello packet not to establish neighbor
969 flog_warn(EC_OSPF_PACKET
,
970 "Packet %pI4 [Hello:RECV]: T-bit on, drop it.",
974 #endif /* REJECT_IF_TBIT_ON */
976 if (CHECK_FLAG(oi
->ospf
->config
, OSPF_OPAQUE_CAPABLE
)
977 && CHECK_FLAG(hello
->options
, OSPF_OPTION_O
)) {
979 * This router does know the correct usage of O-bit
980 * the bit should be set in DD packet only.
982 flog_warn(EC_OSPF_PACKET
,
983 "Packet %pI4 [Hello:RECV]: O-bit abuse?",
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 */
992 /* new for NSSA is to ensure that NP is on and E is off */
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
))) {
1001 "NSSA-Packet-%pI4[Hello:RECV]: my options: %x, his options %x",
1002 &ospfh
->router_id
, OPTIONS(oi
),
1006 if (IS_DEBUG_OSPF_NSSA
)
1007 zlog_debug("NSSA-Hello:RECV:Packet from %pI4:",
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
)) {
1019 "Packet %pI4 [Hello:RECV]: my options: %x, his options %x",
1020 &ospfh
->router_id
, OPTIONS(oi
),
1025 /* get neighbour struct */
1026 nbr
= ospf_nbr_get(oi
, ospfh
, iph
, &p
);
1028 /* neighbour must be valid, ospf_nbr_get creates if none existed */
1031 old_state
= nbr
->state
;
1033 /* Add event to thread. */
1034 OSPF_NSM_EVENT_SCHEDULE(nbr
, NSM_PacketReceived
);
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
);
1049 /* on NBMA network type, it happens to receive bidirectional Hello
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
;
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
;
1067 /* If the router is DR_OTHER, RESTARTER will not wait
1068 * until it receives the hello from it if it receives
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.
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
;
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
);
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
);
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
);
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
);
1110 /* Neighbor priority check. */
1111 if (nbr
->priority
>= 0 && nbr
->priority
!= hello
->priority
)
1112 OSPF_ISM_EVENT_SCHEDULE(oi
, ISM_NeighborChange
);
1114 /* Set neighbor information. */
1115 nbr
->priority
= hello
->priority
;
1116 nbr
->d_router
= hello
->d_router
;
1117 nbr
->bd_router
= hello
->bd_router
;
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
)
1124 nbr
->last_recv
.flags
= dd
->flags
;
1125 nbr
->last_recv
.options
= dd
->options
;
1126 nbr
->last_recv
.dd_seqnum
= ntohl(dd
->dd_seqnum
);
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
)
1134 struct ospf_lsa
*new, *find
;
1135 struct lsa_header
*lsah
;
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
);
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.",
1148 OSPF_NSM_EVENT_SCHEDULE(nbr
, NSM_SeqNumberMismatch
);
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
);
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
1166 allow if from NSSA. */
1167 if (oi
->area
->external_routing
== OSPF_AREA_STUB
) {
1170 "Packet [DD:RECV]: LSA[Type%d:%pI4] from %s area.",
1171 lsah
->type
, &lsah
->id
,
1172 (oi
->area
->external_routing
1176 OSPF_NSM_EVENT_SCHEDULE(nbr
,
1177 NSM_SeqNumberMismatch
);
1185 /* Create LS-request object. */
1186 new = ospf_ls_request_new(lsah
);
1188 /* Lookup received LSA, then add LS request list. */
1189 find
= ospf_lsa_lookup_by_header(oi
->area
, lsah
);
1191 /* ospf_lsa_more_recent is fine with NULL pointers */
1192 switch (ospf_lsa_more_recent(find
, new)) {
1194 /* Neighbour has a more recent LSA, we must request it
1196 ospf_ls_request_add(nbr
, new);
1199 /* If we have a copy of this LSA, it's either less
1201 * and we're requesting it from neighbour (the case
1203 * it's as recent and we both have same copy (this
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.
1210 * See: draft-ogier-ospf-dbex-opt-00.txt, describing the
1211 * backward compatible optimisation to OSPF DB Exchange
1213 * DB Description process implemented here.
1216 ospf_lsdb_delete(&nbr
->db_sum
, find
);
1217 ospf_lsa_discard(new);
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
1224 if (IS_DEBUG_OSPF_EVENT
)
1226 "Packet [DD:RECV]: LSA received Type %d, ID %pI4 is not recent.",
1227 lsah
->type
, &lsah
->id
);
1228 ospf_lsa_discard(new);
1233 if (IS_SET_DD_MS(nbr
->dd_flags
)) {
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
);
1240 ospf_db_desc_send(nbr
);
1244 nbr
->dd_seqnum
= ntohl(dd
->dd_seqnum
);
1246 /* Send DD packet in reply.
1248 * Must be done to acknowledge the Master's DD, regardless of
1249 * whether we have more LSAs ourselves to describe.
1251 * This function will clear the 'More' bit, if after this DD
1252 * we have no more LSAs to describe to the master..
1254 ospf_db_desc_send(nbr
);
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
);
1261 /* Save received neighbor values from DD. */
1262 ospf_db_desc_save_current(nbr
, dd
);
1265 ospf_ls_req_send(nbr
);
1268 static int ospf_db_desc_is_dup(struct ospf_db_desc
*dd
,
1269 struct ospf_neighbor
*nbr
)
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
))
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
,
1285 struct ospf_db_desc
*dd
;
1286 struct ospf_neighbor
*nbr
;
1288 /* Increment statistics. */
1291 dd
= (struct ospf_db_desc
*)stream_pnt(s
);
1293 nbr
= ospf_nbr_lookup(oi
, iph
, ospfh
);
1295 flog_warn(EC_OSPF_PACKET
, "Packet[DD]: Unknown Neighbor %pI4",
1301 if ((OSPF_IF_PARAM(oi
, mtu_ignore
) == 0)
1302 && (ntohs(dd
->mtu
) > oi
->ifp
->mtu
)) {
1305 "Packet[DD]: Neighbor %pI4 MTU %u is larger than [%s]'s MTU %u",
1306 &nbr
->router_id
, ntohs(dd
->mtu
), IF_NAME(oi
),
1312 * XXX HACK by Hasso Tepper. Setting N/P bit in NSSA area DD packets is
1314 * required. In fact at least JunOS sends DD packets with P bit clear.
1315 * Until proper solution is developped, this hack should help.
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
1320 * implementations follow E-bit semantics and set it in DD options, and
1322 * treat it as unspecified and hence follow the directive "default for
1323 * options is clear", ie unset.
1325 * Reset the flag, as ospfd follows E-bit semantics.
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
)
1332 "Packet[DD]: Neighbour %pI4: Has NSSA capability, sends with N bit clear in DD options",
1334 SET_FLAG(dd
->options
, OSPF_OPTION_NP
);
1337 #ifdef REJECT_IF_TBIT_ON
1338 if (CHECK_FLAG(dd
->options
, OSPF_OPTION_MT
)) {
1340 * In Hello protocol, optional capability must have checked
1341 * to prevent this T-bit enabled router be my neighbor.
1343 flog_warn(EC_OSPF_PACKET
, "Packet[DD]: Neighbor %pI4: T-bit on?",
1347 #endif /* REJECT_IF_TBIT_ON */
1349 if (CHECK_FLAG(dd
->options
, OSPF_OPTION_O
)
1350 && !CHECK_FLAG(oi
->ospf
->config
, OSPF_OPAQUE_CAPABLE
)) {
1352 * This node is not configured to handle O-bit, for now.
1353 * Clear it to ignore unsupported capability proposed by
1356 UNSET_FLAG(dd
->options
, OSPF_OPTION_O
);
1359 /* Add event to thread. */
1360 OSPF_NSM_EVENT_SCHEDULE(nbr
, NSM_PacketReceived
);
1362 if (CHECK_FLAG(oi
->ospf
->config
, OSPF_LOG_ADJACENCY_DETAIL
))
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
,
1367 lookup_msg(ospf_nsm_state_msg
, nbr
->state
, NULL
),
1368 ntohl(dd
->dd_seqnum
), nbr
->dd_seqnum
);
1370 /* Process DD packet by neighbor status. */
1371 switch (nbr
->state
) {
1375 if (CHECK_FLAG(oi
->ospf
->config
, OSPF_LOG_ADJACENCY_DETAIL
))
1377 "Packet[DD]: Neighbor %pI4 state is %s, packet discarded.",
1379 lookup_msg(ospf_nsm_state_msg
, nbr
->state
,
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
)
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
)
1396 /* We're Slave---obey */
1397 if (CHECK_FLAG(oi
->ospf
->config
,
1398 OSPF_LOG_ADJACENCY_DETAIL
))
1400 "Packet[DD]: Neighbor %pI4 Negotiation done (Slave).",
1403 nbr
->dd_seqnum
= ntohl(dd
->dd_seqnum
);
1406 UNSET_FLAG(nbr
->dd_flags
,
1407 (OSPF_DD_FLAG_MS
| OSPF_DD_FLAG_I
));
1409 /* We're Master, ignore the initial DBD from
1411 if (CHECK_FLAG(oi
->ospf
->config
,
1412 OSPF_LOG_ADJACENCY_DETAIL
))
1414 "Packet[DD]: Neighbor %pI4: Initial DBD from Slave, ignoring.",
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
)
1425 "Packet[DD]: Neighbor %pI4 Negotiation done (Master).",
1427 /* Reset I, leaving MS */
1428 UNSET_FLAG(nbr
->dd_flags
, OSPF_DD_FLAG_I
);
1430 flog_warn(EC_OSPF_PACKET
,
1431 "Packet[DD]: Neighbor %pI4 Negotiation fails.",
1436 /* This is where the real Options are saved */
1437 nbr
->options
= dd
->options
;
1439 if (CHECK_FLAG(oi
->ospf
->config
, OSPF_OPAQUE_CAPABLE
)) {
1440 if (IS_DEBUG_OSPF_EVENT
)
1442 "Neighbor[%pI4] is %sOpaque-capable.",
1444 CHECK_FLAG(nbr
->options
, OSPF_OPTION_O
)
1448 if (!CHECK_FLAG(nbr
->options
, OSPF_OPTION_O
)
1449 && IPV4_ADDR_SAME(&DR(oi
),
1450 &nbr
->address
.u
.prefix4
)) {
1453 "DR-neighbor[%pI4] is NOT opaque-capable; Opaque-LSAs cannot be reliably advertised in this network.",
1455 /* This situation is undesirable, but not a real
1460 OSPF_NSM_EVENT_EXECUTE(nbr
, NSM_NegotiationDone
);
1462 /* continue processing rest of packet. */
1463 ospf_db_desc_proc(s
, oi
, nbr
, dd
, size
);
1466 if (ospf_db_desc_is_dup(dd
, nbr
)) {
1467 if (IS_SET_DD_MS(nbr
->dd_flags
))
1468 /* Master: discard duplicated DD packet. */
1470 "Packet[DD] (Master): Neighbor %pI4 packet duplicated.",
1473 /* Slave: cause to retransmit the last Database
1477 "Packet[DD] [Slave]: Neighbor %pI4 packet duplicated.",
1479 ospf_db_desc_resend(nbr
);
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.",
1491 OSPF_NSM_EVENT_SCHEDULE(nbr
, NSM_SeqNumberMismatch
);
1492 if (IS_DEBUG_OSPF_EVENT
)
1494 "Packet[DD]: dd->flags=%d, nbr->dd_flags=%d",
1495 dd
->flags
, nbr
->dd_flags
);
1499 /* Check initialize bit is set. */
1500 if (IS_SET_DD_I(dd
->flags
)) {
1501 zlog_info("Packet[DD]: Neighbor %pI4 I-bit set.",
1503 OSPF_NSM_EVENT_SCHEDULE(nbr
, NSM_SeqNumberMismatch
);
1507 /* Check DD Options. */
1508 if (dd
->options
!= nbr
->options
) {
1509 flog_warn(EC_OSPF_PACKET
,
1510 "Packet[DD]: Neighbor %pI4 options mismatch.",
1512 OSPF_NSM_EVENT_SCHEDULE(nbr
, NSM_SeqNumberMismatch
);
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)) {
1523 "Packet[DD]: Neighbor %pI4 sequence number mismatch.",
1525 OSPF_NSM_EVENT_SCHEDULE(nbr
, NSM_SeqNumberMismatch
);
1529 /* Continue processing rest of packet. */
1530 ospf_db_desc_proc(s
, oi
, nbr
, dd
, size
);
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. */
1538 "Packet[DD]: Neighbor %pI4 duplicated, packet discarded.",
1542 if (monotime_since(&nbr
->last_send_ts
, NULL
)
1543 < nbr
->v_inactivity
* 1000000LL) {
1544 /* In states Loading and Full the slave
1546 its last Database Description packet
1548 duplicate Database Description
1550 from the master. For this reason the
1552 wait RouterDeadInterval seconds
1554 last Database Description packet.
1556 Database Description packet from the
1558 this interval will generate a
1560 neighbor event. RFC2328 Section 10.8
1562 ospf_db_desc_resend(nbr
);
1568 OSPF_NSM_EVENT_SCHEDULE(nbr
, NSM_SeqNumberMismatch
);
1571 flog_warn(EC_OSPF_PACKET
,
1572 "Packet[DD]: Neighbor %pI4 NSM illegal status %u.",
1573 &nbr
->router_id
, nbr
->state
);
1578 #define OSPF_LSA_KEY_SIZE 12 /* type(4) + id(4) + ar(4) */
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
,
1585 struct ospf_neighbor
*nbr
;
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
;
1593 /* Increment statistics. */
1596 nbr
= ospf_nbr_lookup(oi
, iph
, ospfh
);
1598 flog_warn(EC_OSPF_PACKET
,
1599 "Link State Request: Unknown Neighbor %pI4",
1604 /* Add event to thread. */
1605 OSPF_NSM_EVENT_SCHEDULE(nbr
, NSM_PacketReceived
);
1607 /* Neighbor State should be Exchange or later. */
1608 if (nbr
->state
!= NSM_Exchange
&& nbr
->state
!= NSM_Loading
1609 && nbr
->state
!= NSM_Full
) {
1612 "Link State Request received from %pI4: Neighbor state is %s, packet discarded.",
1614 lookup_msg(ospf_nsm_state_msg
, nbr
->state
, NULL
));
1618 /* Send Link State Update for ALL requested LSAs. */
1619 ls_upd
= list_new();
1620 length
= OSPF_HEADER_SIZE
+ OSPF_LS_UPD_MIN_SIZE
;
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
);
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
);
1635 /* Search proper LSA in LSDB. */
1636 find
= ospf_lsa_lookup(oi
->ospf
, oi
->area
, ls_type
, ls_id
,
1639 OSPF_NSM_EVENT_SCHEDULE(nbr
, NSM_BadLSReq
);
1640 list_delete(&ls_upd
);
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);
1650 ospf_ls_upd_send(nbr
, ls_upd
,
1651 OSPF_SEND_PACKET_INDIRECT
, 0);
1653 /* Only remove list contents. Keep ls_upd. */
1654 list_delete_all_node(ls_upd
);
1656 length
= OSPF_HEADER_SIZE
+ OSPF_LS_UPD_MIN_SIZE
;
1659 /* Append LSA to update list. */
1660 listnode_add(ls_upd
, find
);
1661 length
+= ntohs(find
->data
->length
);
1663 size
-= OSPF_LSA_KEY_SIZE
;
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
,
1672 ospf_ls_upd_send(nbr
, ls_upd
, OSPF_SEND_PACKET_INDIRECT
,
1675 list_delete(&ls_upd
);
1677 list_delete(&ls_upd
);
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
,
1684 struct ospf_interface
*oi
, size_t size
)
1686 uint16_t count
, sum
;
1688 struct lsa_header
*lsah
;
1689 struct ospf_lsa
*lsa
;
1694 count
= stream_getl(s
);
1695 size
-= OSPF_LS_UPD_MIN_SIZE
; /* # LSAs */
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
);
1702 if (length
> size
) {
1705 "Link State Update: LSA length exceeds packet size.");
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
1714 * to identify problem source on the one hand and to
1716 * chance to compress repeated messages in syslog on the
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
,
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",
1736 * What if the received LSA's age is greater than MaxAge?
1737 * Treat it as a MaxAge case -- endo.
1739 if (ntohs(lsah
->ls_age
) > OSPF_LSA_MAXAGE
)
1740 lsah
->ls_age
= htons(OSPF_LSA_MAXAGE
);
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
))) {
1749 * This neighbor must know the exact usage of
1751 * the bit will be set in Type-9,10,11 LSAs
1754 flog_warn(EC_OSPF_PACKET
,
1755 "LSA[Type%d:%pI4]: O-bit abuse?",
1756 lsah
->type
, &lsah
->id
);
1759 #endif /* STRICT_OBIT_USAGE_CHECK */
1761 /* Do not take in AS External Opaque-LSAs if we are a
1763 if (lsah
->type
== OSPF_OPAQUE_AS_LSA
1764 && nbr
->oi
->area
->external_routing
1765 != OSPF_AREA_DEFAULT
) {
1766 if (IS_DEBUG_OSPF_EVENT
)
1768 "LSA[Type%d:%pI4]: We are a stub, don't take this LSA.",
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
);
1780 /* Create OSPF LSA instance. */
1781 lsa
= ospf_lsa_new_and_data(length
);
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
:
1791 case OSPF_OPAQUE_LINK_LSA
:
1792 lsa
->oi
= oi
; /* Remember incoming interface for
1793 flooding control. */
1796 lsa
->area
= oi
->area
;
1800 memcpy(lsa
->data
, lsah
, length
);
1802 if (IS_DEBUG_OSPF_EVENT
)
1804 "LSA[Type%d:%pI4]: %p new LSA created with Link State Update",
1805 lsa
->data
->type
, &lsa
->data
->id
,
1807 listnode_add(lsas
, lsa
);
1813 /* Cleanup Update list. */
1814 static void ospf_upd_list_clean(struct list
*lsas
)
1816 struct listnode
*node
, *nnode
;
1817 struct ospf_lsa
*lsa
;
1819 for (ALL_LIST_ELEMENTS(lsas
, node
, nnode
, lsa
))
1820 ospf_lsa_discard(lsa
);
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
)
1830 struct ospf_neighbor
*nbr
;
1832 struct listnode
*node
, *nnode
;
1833 struct ospf_lsa
*lsa
= NULL
;
1834 /* unsigned long ls_req_found = 0; */
1836 /* Dis-assemble the stream, update each entry, re-encapsulate for
1839 /* Increment statistics. */
1842 /* Check neighbor. */
1843 nbr
= ospf_nbr_lookup(oi
, iph
, ospfh
);
1845 flog_warn(EC_OSPF_PACKET
,
1846 "Link State Update: Unknown Neighbor %pI4 on int: %s",
1847 &ospfh
->router_id
, IF_NAME(oi
));
1851 /* Add event to thread. */
1852 OSPF_NSM_EVENT_SCHEDULE(nbr
, NSM_PacketReceived
);
1854 /* Check neighbor state. */
1855 if (nbr
->state
< NSM_Exchange
) {
1856 if (IS_DEBUG_OSPF(nsm
, NSM_EVENTS
))
1858 "Link State Update: Neighbor[%pI4] state %s is less than Exchange",
1860 lookup_msg(ospf_nsm_state_msg
, nbr
->state
,
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.
1869 lsas
= ospf_ls_upd_list_lsa(nbr
, s
, oi
, size
);
1873 #define DISCARD_LSA(L, N) \
1875 if (IS_DEBUG_OSPF_EVENT) \
1877 "ospf_lsa_discard() in ospf_ls_upd() point %d: lsa %p" \
1879 N, (void *)lsa, (int)lsa->data->type); \
1880 ospf_lsa_discard(L); \
1884 /* Process each LSA received in the one packet.
1886 * Numbers in parentheses, e.g. (1), (2), etc., and the corresponding
1887 * text below are from the steps in RFC 2328, Section 13.
1889 for (ALL_LIST_ELEMENTS(lsas
, node
, nnode
, lsa
)) {
1890 struct ospf_lsa
*ls_ret
, *current
;
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
);
1898 listnode_delete(lsas
,
1899 lsa
); /* We don't need it in list anymore */
1901 /* (1) Validate Checksum - Done above by ospf_ls_upd_list_lsa()
1904 /* (2) LSA Type - Done above by ospf_ls_upd_list_lsa() */
1906 /* (3) Do not take in AS External LSAs if we are a stub or NSSA.
1909 /* Do not take in AS NSSA if this neighbor and we are not NSSA
1912 /* Do take in Type-7's if we are an NSSA */
1914 /* If we are also an ABR, later translate them to a Type-5
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. */
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
)
1926 "Incoming External LSA Discarded: We are NSSA/STUB Area");
1927 DISCARD_LSA(lsa
, 1);
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
)
1934 "Incoming NSSA LSA Discarded: Not NSSA Area");
1935 DISCARD_LSA(lsa
, 2);
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
)) {
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
);
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);
1953 /* Find the LSA in the current database. */
1955 current
= ospf_lsa_lookup_by_header(oi
->area
, lsa
->data
);
1957 /* (4) If the LSA's LS age is equal to MaxAge, and there is
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
1962 then take the following actions: */
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
);
1969 /* (4b) Discard LSA. */
1970 if (IS_DEBUG_OSPF(lsa
, LSA
)) {
1972 "Link State Update[%s]: LS age is equal to MaxAge.",
1975 DISCARD_LSA(lsa
, 3);
1978 if (IS_OPAQUE_LSA(lsa
->data
->type
)
1979 && IPV4_ADDR_SAME(&lsa
->data
->adv_router
,
1980 &oi
->ospf
->router_id
)) {
1982 * Even if initial flushing seems to be completed, there
1984 * be a case that self-originated LSA with MaxAge still
1986 * in the routing domain.
1987 * Just send an LSAck message to cease retransmission.
1989 if (IS_LSA_MAXAGE(lsa
)) {
1990 zlog_info("LSA[%s]: Boomerang effect?",
1992 ospf_ls_ack_send(nbr
, lsa
);
1993 ospf_lsa_discard(lsa
);
1995 if (current
!= NULL
&& !IS_LSA_MAXAGE(current
))
1996 ospf_opaque_lsa_refresh_schedule(
2002 * If an instance of self-originated Opaque-LSA is not
2004 * in the LSDB, there are some possible cases here.
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.
2010 * Anyway, it is still this node's responsibility to
2012 * Otherwise, the LSA instance remains in the routing
2014 * until its age reaches to MaxAge.
2016 /* XXX: We should deal with this for *ALL* LSAs, not
2018 if (current
== NULL
) {
2019 if (IS_DEBUG_OSPF_EVENT
)
2021 "LSA[%s]: Previously originated Opaque-LSA,not found in the LSDB.",
2024 SET_FLAG(lsa
->flags
, OSPF_LSA_SELF
);
2026 ospf_ls_ack_send(nbr
, lsa
);
2028 if (!ospf
->gr_info
.restart_in_progress
) {
2029 ospf_opaque_self_originated_lsa_received(
2036 /* It might be happen that received LSA is self-originated
2038 * router ID is changed. So, we should check if LSA is a
2040 * Link State ID is one of the router's own IP interface
2041 * addresses but whose
2042 * Advertising Router is not equal to the router's own Router ID
2043 * According to RFC 2328 12.4.2 and 13.4 this LSA should be
2047 if (lsa
->data
->type
== OSPF_NETWORK_LSA
) {
2048 struct listnode
*oinode
, *oinnode
;
2049 struct ospf_interface
*out_if
;
2052 for (ALL_LIST_ELEMENTS(oi
->ospf
->oiflist
, oinode
,
2057 if ((IPV4_ADDR_SAME(&out_if
->address
->u
.prefix4
,
2059 && (!(IPV4_ADDR_SAME(
2060 &oi
->ospf
->router_id
,
2061 &lsa
->data
->adv_router
)))) {
2062 if (out_if
->network_lsa_self
) {
2063 ospf_lsa_flush_area(
2065 if (IS_DEBUG_OSPF_EVENT
)
2067 "ospf_lsa_discard() in ospf_ls_upd() point 9: lsa %p Type-%d",
2071 ospf_lsa_discard(lsa
);
2081 /* (5) Find the instance of this LSA that is currently contained
2082 in the router's link state database. If there is no
2083 database copy, or the received LSA is more recent than
2084 the database copy the following steps must be performed.
2085 (The sub steps from RFC 2328 section 13 step (5) will be
2090 || (ret
= ospf_lsa_more_recent(current
, lsa
)) < 0) {
2092 if (current
&& (lsa
->data
->ls_seqnum
==
2093 htonl(OSPF_MAX_SEQUENCE_NUMBER
)
2094 && !IS_LSA_MAXAGE(lsa
))) {
2096 "Link State Update[%s]: has Max Seq but not MaxAge. Dropping it",
2099 DISCARD_LSA(lsa
, 4);
2102 /* Actual flooding procedure. */
2103 if (ospf_flood(oi
->ospf
, nbr
, current
, lsa
)
2104 < 0) /* Trap NSSA later. */
2105 DISCARD_LSA(lsa
, 5);
2109 /* (6) Else, If there is an instance of the LSA on the sending
2110 neighbor's Link state request list, an error has occurred in
2111 the Database Exchange process. In this case, restart the
2112 Database Exchange process by generating the neighbor event
2113 BadLSReq for the sending neighbor and stop processing the
2114 Link State Update packet. */
2116 if (ospf_ls_request_lookup(nbr
, lsa
)) {
2117 OSPF_NSM_EVENT_SCHEDULE(nbr
, NSM_BadLSReq
);
2120 "LSA[%s] instance exists on Link state request list",
2123 /* Clean list of LSAs. */
2124 ospf_upd_list_clean(lsas
);
2125 /* this lsa is not on lsas list already. */
2126 ospf_lsa_discard(lsa
);
2130 /* If the received LSA is the same instance as the database copy
2131 (i.e., neither one is more recent) the following two steps
2132 should be performed: */
2135 /* If the LSA is listed in the Link state retransmission
2137 for the receiving adjacency, the router itself is
2139 an acknowledgment for this LSA. The router should
2141 received LSA as an acknowledgment by removing the LSA
2143 the Link state retransmission list. This is termed
2145 "implied acknowledgment". */
2147 ls_ret
= ospf_ls_retransmit_lookup(nbr
, lsa
);
2149 if (ls_ret
!= NULL
) {
2150 ospf_ls_retransmit_delete(nbr
, ls_ret
);
2152 /* Delayed acknowledgment sent if advertisement
2154 from Designated Router, otherwise do nothing.
2156 if (oi
->state
== ISM_Backup
)
2160 ospf_lsa_lock(lsa
));
2162 DISCARD_LSA(lsa
, 6);
2164 /* Acknowledge the receipt of the LSA by sending a
2165 Link State Acknowledgment packet back out the
2169 ospf_ls_ack_send(nbr
, lsa
);
2170 DISCARD_LSA(lsa
, 7);
2174 /* The database copy is more recent. If the database copy
2175 has LS age equal to MaxAge and LS sequence number equal to
2176 MaxSequenceNumber, simply discard the received LSA without
2177 acknowledging it. (In this case, the LSA's LS sequence number
2179 wrapping, and the MaxSequenceNumber LSA must be completely
2180 flushed before any new LSA instance can be introduced). */
2182 else if (ret
> 0) /* Database copy is more recent */
2184 if (IS_LSA_MAXAGE(current
)
2185 && current
->data
->ls_seqnum
2186 == htonl(OSPF_MAX_SEQUENCE_NUMBER
)) {
2187 DISCARD_LSA(lsa
, 8);
2189 /* Otherwise, as long as the database copy has not been
2191 Link State Update within the last MinLSArrival
2193 database copy back to the sending neighbor,
2195 a Link State Update Packet. The Link State Update
2197 be sent directly to the neighbor. In so doing, do not
2199 database copy of the LSA on the neighbor's link state
2200 retransmission list, and do not acknowledge the
2202 recent) LSA instance. */
2204 if (monotime_since(¤t
->tv_orig
, NULL
)
2205 >= ospf
->min_ls_arrival
* 1000LL)
2206 /* Trap NSSA type later.*/
2207 ospf_ls_upd_send_lsa(
2209 OSPF_SEND_PACKET_DIRECT
);
2210 DISCARD_LSA(lsa
, 9);
2216 assert(listcount(lsas
) == 0);
2219 if (ospf
->gr_info
.restart_in_progress
)
2220 ospf_gr_check_lsdb_consistency(oi
->ospf
, oi
->area
);
2223 /* OSPF Link State Acknowledgment message read -- RFC2328 Section 13.7. */
2224 static void ospf_ls_ack(struct ip
*iph
, struct ospf_header
*ospfh
,
2225 struct stream
*s
, struct ospf_interface
*oi
,
2228 struct ospf_neighbor
*nbr
;
2230 /* increment statistics. */
2233 nbr
= ospf_nbr_lookup(oi
, iph
, ospfh
);
2235 flog_warn(EC_OSPF_PACKET
,
2236 "Link State Acknowledgment: Unknown Neighbor %pI4",
2241 /* Add event to thread. */
2242 OSPF_NSM_EVENT_SCHEDULE(nbr
, NSM_PacketReceived
);
2244 if (nbr
->state
< NSM_Exchange
) {
2245 if (IS_DEBUG_OSPF(nsm
, NSM_EVENTS
))
2247 "Link State Acknowledgment: Neighbor[%pI4] state %s is less than Exchange",
2249 lookup_msg(ospf_nsm_state_msg
, nbr
->state
,
2254 while (size
>= OSPF_LSA_HEADER_SIZE
) {
2255 struct ospf_lsa
*lsa
, *lsr
;
2257 lsa
= ospf_lsa_new();
2258 lsa
->data
= (struct lsa_header
*)stream_pnt(s
);
2259 lsa
->vrf_id
= oi
->ospf
->vrf_id
;
2261 /* lsah = (struct lsa_header *) stream_pnt (s); */
2262 size
-= OSPF_LSA_HEADER_SIZE
;
2263 stream_forward_getp(s
, OSPF_LSA_HEADER_SIZE
);
2265 if (lsa
->data
->type
< OSPF_MIN_LSA
2266 || lsa
->data
->type
>= OSPF_MAX_LSA
) {
2268 ospf_lsa_discard(lsa
);
2272 lsr
= ospf_ls_retransmit_lookup(nbr
, lsa
);
2274 if (lsr
!= NULL
&& ospf_lsa_more_recent(lsr
, lsa
) == 0)
2275 ospf_ls_retransmit_delete(nbr
, lsr
);
2278 ospf_lsa_discard(lsa
);
2284 static struct stream
*ospf_recv_packet(struct ospf
*ospf
, int fd
,
2285 struct interface
**ifp
,
2286 struct stream
*ibuf
)
2291 ifindex_t ifindex
= 0;
2293 /* Header and data both require alignment. */
2294 char buff
[CMSG_SPACE(SOPT_SIZE_CMSG_IFINDEX_IPV4())];
2297 memset(&msgh
, 0, sizeof(struct msghdr
));
2298 msgh
.msg_iov
= &iov
;
2299 msgh
.msg_iovlen
= 1;
2300 msgh
.msg_control
= (caddr_t
)buff
;
2301 msgh
.msg_controllen
= sizeof(buff
);
2303 ret
= stream_recvmsg(ibuf
, fd
, &msgh
, MSG_DONTWAIT
,
2304 OSPF_MAX_PACKET_SIZE
+ 1);
2306 if (errno
!= EAGAIN
&& errno
!= EWOULDBLOCK
)
2307 flog_warn(EC_OSPF_PACKET
, "stream_recvmsg failed: %s",
2308 safe_strerror(errno
));
2311 if ((unsigned int)ret
< sizeof(struct ip
)) {
2314 "ospf_recv_packet: discarding runt packet of length %d (ip header size is %u)",
2315 ret
, (unsigned int)sizeof(iph
));
2319 /* Note that there should not be alignment problems with this assignment
2320 because this is at the beginning of the stream data buffer. */
2321 iph
= (struct ip
*)STREAM_DATA(ibuf
);
2322 sockopt_iphdrincl_swab_systoh(iph
);
2324 ip_len
= iph
->ip_len
;
2326 #if defined(__FreeBSD__) && (__FreeBSD_version < 1000000)
2328 * Kernel network code touches incoming IP header parameters,
2329 * before protocol specific processing.
2331 * 1) Convert byteorder to host representation.
2332 * --> ip_len, ip_id, ip_off
2334 * 2) Adjust ip_len to strip IP header size!
2335 * --> If user process receives entire IP packet via RAW
2336 * socket, it must consider adding IP header size to
2337 * the "ip_len" field of "ip" structure.
2339 * For more details, see <netinet/ip_input.c>.
2341 ip_len
= ip_len
+ (iph
->ip_hl
<< 2);
2344 #if defined(__DragonFly__)
2346 * in DragonFly's raw socket, ip_len/ip_off are read
2347 * in network byte order.
2348 * As OpenBSD < 200311 adjust ip_len to strip IP header size!
2350 ip_len
= ntohs(iph
->ip_len
) + (iph
->ip_hl
<< 2);
2353 ifindex
= getsockopt_ifindex(AF_INET
, &msgh
);
2355 *ifp
= if_lookup_by_index(ifindex
, ospf
->vrf_id
);
2357 if (ret
!= ip_len
) {
2360 "ospf_recv_packet read length mismatch: ip_len is %d, but recvmsg returned %d",
2365 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2366 zlog_debug("%s: fd %d(%s) on interface %d(%s)", __func__
, fd
,
2367 ospf_get_name(ospf
), ifindex
,
2368 *ifp
? (*ifp
)->name
: "Unknown");
2372 static struct ospf_interface
*
2373 ospf_associate_packet_vl(struct ospf
*ospf
, struct interface
*ifp
,
2374 struct ip
*iph
, struct ospf_header
*ospfh
)
2376 struct ospf_interface
*rcv_oi
;
2377 struct ospf_vl_data
*vl_data
;
2378 struct ospf_area
*vl_area
;
2379 struct listnode
*node
;
2381 if (IN_MULTICAST(ntohl(iph
->ip_dst
.s_addr
))
2382 || !OSPF_IS_AREA_BACKBONE(ospfh
))
2385 /* look for local OSPF interface matching the destination
2386 * to determine Area ID. We presume therefore the destination address
2387 * is unique, or at least (for "unnumbered" links), not used in other
2390 if ((rcv_oi
= ospf_if_lookup_by_local_addr(ospf
, NULL
, iph
->ip_dst
))
2394 for (ALL_LIST_ELEMENTS_RO(ospf
->vlinks
, node
, vl_data
)) {
2396 ospf_area_lookup_by_area_id(ospf
, vl_data
->vl_area_id
);
2400 if (OSPF_AREA_SAME(&vl_area
, &rcv_oi
->area
)
2401 && IPV4_ADDR_SAME(&vl_data
->vl_peer
, &ospfh
->router_id
)) {
2402 if (IS_DEBUG_OSPF_EVENT
)
2403 zlog_debug("associating packet with %s",
2404 IF_NAME(vl_data
->vl_oi
));
2405 if (!CHECK_FLAG(vl_data
->vl_oi
->ifp
->flags
, IFF_UP
)) {
2406 if (IS_DEBUG_OSPF_EVENT
)
2408 "This VL is not up yet, sorry");
2412 return vl_data
->vl_oi
;
2416 if (IS_DEBUG_OSPF_EVENT
)
2417 zlog_debug("couldn't find any VL to associate the packet with");
2422 static int ospf_check_area_id(struct ospf_interface
*oi
,
2423 struct ospf_header
*ospfh
)
2425 /* Check match the Area ID of the receiving interface. */
2426 if (OSPF_AREA_SAME(&oi
->area
, &ospfh
))
2432 /* Unbound socket will accept any Raw IP packets if proto is matched.
2433 To prevent it, compare src IP address and i/f address with masking
2434 i/f network mask. */
2435 static int ospf_check_network_mask(struct ospf_interface
*oi
,
2436 struct in_addr ip_src
)
2438 struct in_addr mask
, me
, him
;
2440 if (oi
->type
== OSPF_IFTYPE_POINTOPOINT
2441 || oi
->type
== OSPF_IFTYPE_VIRTUALLINK
)
2444 /* Ignore mask check for max prefix length (32) */
2445 if (oi
->type
== OSPF_IFTYPE_POINTOMULTIPOINT
2446 && oi
->address
->prefixlen
== IPV4_MAX_BITLEN
)
2449 masklen2ip(oi
->address
->prefixlen
, &mask
);
2451 me
.s_addr
= oi
->address
->u
.prefix4
.s_addr
& mask
.s_addr
;
2452 him
.s_addr
= ip_src
.s_addr
& mask
.s_addr
;
2454 if (IPV4_ADDR_SAME(&me
, &him
))
2460 /* Return 1, if the packet is properly authenticated and checksummed,
2461 0 otherwise. In particular, check that AuType header field is valid and
2462 matches the locally configured AuType, and that D.5 requirements are met. */
2463 static int ospf_check_auth(struct ospf_interface
*oi
, struct ospf_header
*ospfh
)
2465 struct crypt_key
*ck
;
2466 uint16_t iface_auth_type
;
2467 uint16_t pkt_auth_type
= ntohs(ospfh
->auth_type
);
2469 switch (pkt_auth_type
) {
2470 case OSPF_AUTH_NULL
: /* RFC2328 D.5.1 */
2471 if (OSPF_AUTH_NULL
!= (iface_auth_type
= ospf_auth_type(oi
))) {
2472 if (IS_DEBUG_OSPF_PACKET(ospfh
->type
- 1, RECV
))
2475 "interface %s: auth-type mismatch, local %s, rcvd Null",
2477 lookup_msg(ospf_auth_type_str
,
2478 iface_auth_type
, NULL
));
2481 if (!ospf_check_sum(ospfh
)) {
2482 if (IS_DEBUG_OSPF_PACKET(ospfh
->type
- 1, RECV
))
2485 "interface %s: Null auth OK, but checksum error, Router-ID %pI4",
2491 case OSPF_AUTH_SIMPLE
: /* RFC2328 D.5.2 */
2492 if (OSPF_AUTH_SIMPLE
2493 != (iface_auth_type
= ospf_auth_type(oi
))) {
2494 if (IS_DEBUG_OSPF_PACKET(ospfh
->type
- 1, RECV
))
2497 "interface %s: auth-type mismatch, local %s, rcvd Simple",
2499 lookup_msg(ospf_auth_type_str
,
2500 iface_auth_type
, NULL
));
2503 if (memcmp(OSPF_IF_PARAM(oi
, auth_simple
), ospfh
->u
.auth_data
,
2504 OSPF_AUTH_SIMPLE_SIZE
)) {
2505 if (IS_DEBUG_OSPF_PACKET(ospfh
->type
- 1, RECV
))
2506 flog_warn(EC_OSPF_PACKET
,
2507 "interface %s: Simple auth failed",
2511 if (!ospf_check_sum(ospfh
)) {
2512 if (IS_DEBUG_OSPF_PACKET(ospfh
->type
- 1, RECV
))
2515 "interface %s: Simple auth OK, checksum error, Router-ID %pI4",
2521 case OSPF_AUTH_CRYPTOGRAPHIC
: /* RFC2328 D.5.3 */
2522 if (OSPF_AUTH_CRYPTOGRAPHIC
2523 != (iface_auth_type
= ospf_auth_type(oi
))) {
2524 if (IS_DEBUG_OSPF_PACKET(ospfh
->type
- 1, RECV
))
2527 "interface %s: auth-type mismatch, local %s, rcvd Cryptographic",
2529 lookup_msg(ospf_auth_type_str
,
2530 iface_auth_type
, NULL
));
2533 if (ospfh
->checksum
) {
2534 if (IS_DEBUG_OSPF_PACKET(ospfh
->type
- 1, RECV
))
2537 "interface %s: OSPF header checksum is not 0",
2541 /* only MD5 crypto method can pass ospf_packet_examin() */
2542 if (NULL
== (ck
= listgetdata(
2543 listtail(OSPF_IF_PARAM(oi
, auth_crypt
))))
2544 || ospfh
->u
.crypt
.key_id
!= ck
->key_id
||
2545 /* Condition above uses the last key ID on the list,
2547 different from what ospf_crypt_key_lookup() does. A
2549 !ospf_check_md5_digest(oi
, ospfh
)) {
2550 if (IS_DEBUG_OSPF_PACKET(ospfh
->type
- 1, RECV
))
2551 flog_warn(EC_OSPF_MD5
,
2552 "interface %s: MD5 auth failed",
2558 if (IS_DEBUG_OSPF_PACKET(ospfh
->type
- 1, RECV
))
2561 "interface %s: invalid packet auth-type (%02x)",
2562 IF_NAME(oi
), pkt_auth_type
);
2567 static int ospf_check_sum(struct ospf_header
*ospfh
)
2572 /* clear auth_data for checksum. */
2573 memset(ospfh
->u
.auth_data
, 0, OSPF_AUTH_SIMPLE_SIZE
);
2575 /* keep checksum and clear. */
2576 sum
= ospfh
->checksum
;
2577 memset(&ospfh
->checksum
, 0, sizeof(uint16_t));
2579 /* calculate checksum. */
2580 ret
= in_cksum(ospfh
, ntohs(ospfh
->length
));
2583 zlog_info("ospf_check_sum(): checksum mismatch, my %X, his %X",
2591 /* Verify, that given link/TOS records are properly sized/aligned and match
2592 Router-LSA "# links" and "# TOS" fields as specified in RFC2328 A.4.2. */
2593 static unsigned ospf_router_lsa_links_examin(struct router_lsa_link
*link
,
2595 const uint16_t num_links
)
2597 unsigned counted_links
= 0, thislinklen
;
2599 while (linkbytes
>= OSPF_ROUTER_LSA_LINK_SIZE
) {
2601 OSPF_ROUTER_LSA_LINK_SIZE
+ 4 * link
->m
[0].tos_count
;
2602 if (thislinklen
> linkbytes
) {
2603 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2604 zlog_debug("%s: length error in link block #%u",
2605 __func__
, counted_links
);
2608 link
= (struct router_lsa_link
*)((caddr_t
)link
+ thislinklen
);
2609 linkbytes
-= thislinklen
;
2612 if (counted_links
!= num_links
) {
2613 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2614 zlog_debug("%s: %u link blocks declared, %u present",
2615 __func__
, num_links
, counted_links
);
2621 /* Verify, that the given LSA is properly sized/aligned (including type-specific
2622 minimum length constraint). */
2623 static unsigned ospf_lsa_examin(struct lsa_header
*lsah
, const uint16_t lsalen
,
2624 const uint8_t headeronly
)
2627 struct router_lsa
*rlsa
;
2628 if (lsah
->type
< OSPF_MAX_LSA
&& ospf_lsa_minlen
[lsah
->type
]
2629 && lsalen
< OSPF_LSA_HEADER_SIZE
+ ospf_lsa_minlen
[lsah
->type
]) {
2630 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2631 zlog_debug("%s: undersized (%u B) %s", __func__
, lsalen
,
2632 lookup_msg(ospf_lsa_type_msg
, lsah
->type
,
2636 switch (lsah
->type
) {
2637 case OSPF_ROUTER_LSA
: {
2639 * RFC2328 A.4.2, LSA header + 4 bytes followed by N>=0
2640 * (12+)-byte link blocks
2642 size_t linkbytes_len
= lsalen
- OSPF_LSA_HEADER_SIZE
2643 - OSPF_ROUTER_LSA_MIN_SIZE
;
2646 * LSA link blocks are variable length but always multiples of
2647 * 4; basic sanity check
2649 if (linkbytes_len
% 4 != 0)
2655 rlsa
= (struct router_lsa
*)lsah
;
2657 ret
= ospf_router_lsa_links_examin(
2658 (struct router_lsa_link
*)rlsa
->link
,
2660 ntohs(rlsa
->links
));
2663 case OSPF_AS_EXTERNAL_LSA
:
2664 /* RFC2328 A.4.5, LSA header + 4 bytes followed by N>=1 12-bytes long
2666 case OSPF_AS_NSSA_LSA
:
2667 /* RFC3101 C, idem */
2668 ret
= (lsalen
- OSPF_LSA_HEADER_SIZE
2669 - OSPF_AS_EXTERNAL_LSA_MIN_SIZE
)
2674 /* Following LSA types are considered OK length-wise as soon as their
2676 * length constraint is met and length of the whole LSA is a multiple of
2678 * (basic LSA header size is already a multiple of 4). */
2679 case OSPF_NETWORK_LSA
:
2680 /* RFC2328 A.4.3, LSA header + 4 bytes followed by N>=1 router-IDs */
2681 case OSPF_SUMMARY_LSA
:
2682 case OSPF_ASBR_SUMMARY_LSA
:
2683 /* RFC2328 A.4.4, LSA header + 4 bytes followed by N>=1 4-bytes TOS
2685 case OSPF_OPAQUE_LINK_LSA
:
2686 case OSPF_OPAQUE_AREA_LSA
:
2687 case OSPF_OPAQUE_AS_LSA
:
2688 /* RFC5250 A.2, "some number of octets (of application-specific
2689 * data) padded to 32-bit alignment." This is considered
2691 * to 4-byte alignment of all other LSA types, see
2692 * OSPF-ALIGNMENT.txt
2693 * file for the detailed analysis of this passage. */
2694 ret
= lsalen
% 4 ? MSG_NG
: MSG_OK
;
2697 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2698 zlog_debug("%s: unsupported LSA type 0x%02x", __func__
,
2702 if (ret
!= MSG_OK
&& IS_DEBUG_OSPF_PACKET(0, RECV
))
2703 zlog_debug("%s: alignment error in %s", __func__
,
2704 lookup_msg(ospf_lsa_type_msg
, lsah
->type
, NULL
));
2708 /* Verify if the provided input buffer is a valid sequence of LSAs. This
2709 includes verification of LSA blocks length/alignment and dispatching
2710 of deeper-level checks. */
2712 ospf_lsaseq_examin(struct lsa_header
*lsah
, /* start of buffered data */
2713 size_t length
, const uint8_t headeronly
,
2714 /* When declared_num_lsas is not 0, compare it to the real
2716 and treat the difference as an error. */
2717 const uint32_t declared_num_lsas
)
2719 uint32_t counted_lsas
= 0;
2723 if (length
< OSPF_LSA_HEADER_SIZE
) {
2724 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2726 "%s: undersized (%zu B) trailing (#%u) LSA header",
2727 __func__
, length
, counted_lsas
);
2730 /* save on ntohs() calls here and in the LSA validator */
2731 lsalen
= ntohs(lsah
->length
);
2732 if (lsalen
< OSPF_LSA_HEADER_SIZE
) {
2733 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2735 "%s: malformed LSA header #%u, declared length is %u B",
2736 __func__
, counted_lsas
, lsalen
);
2740 /* less checks here and in ospf_lsa_examin() */
2741 if (MSG_OK
!= ospf_lsa_examin(lsah
, lsalen
, 1)) {
2742 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2744 "%s: malformed header-only LSA #%u",
2745 __func__
, counted_lsas
);
2748 lsah
= (struct lsa_header
*)((caddr_t
)lsah
2749 + OSPF_LSA_HEADER_SIZE
);
2750 length
-= OSPF_LSA_HEADER_SIZE
;
2752 /* make sure the input buffer is deep enough before
2754 if (lsalen
> length
) {
2755 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2757 "%s: anomaly in LSA #%u: declared length is %u B, buffered length is %zu B",
2758 __func__
, counted_lsas
, lsalen
,
2762 if (MSG_OK
!= ospf_lsa_examin(lsah
, lsalen
, 0)) {
2763 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2764 zlog_debug("%s: malformed LSA #%u",
2765 __func__
, counted_lsas
);
2768 lsah
= (struct lsa_header
*)((caddr_t
)lsah
+ lsalen
);
2774 if (declared_num_lsas
&& counted_lsas
!= declared_num_lsas
) {
2775 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2777 "%s: #LSAs declared (%u) does not match actual (%u)",
2778 __func__
, declared_num_lsas
, counted_lsas
);
2784 /* Verify a complete OSPF packet for proper sizing/alignment. */
2785 static unsigned ospf_packet_examin(struct ospf_header
*oh
,
2786 const unsigned bytesonwire
)
2788 uint16_t bytesdeclared
, bytesauth
;
2790 struct ospf_ls_update
*lsupd
;
2792 /* Length, 1st approximation. */
2793 if (bytesonwire
< OSPF_HEADER_SIZE
) {
2794 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2795 zlog_debug("%s: undersized (%u B) packet", __func__
,
2799 /* Now it is safe to access header fields. Performing length check,
2801 * for possible extra bytes of crypto auth/padding, which are not
2803 * in the OSPF header "length" field. */
2804 if (oh
->version
!= OSPF_VERSION
) {
2805 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2806 zlog_debug("%s: invalid (%u) protocol version",
2807 __func__
, oh
->version
);
2810 bytesdeclared
= ntohs(oh
->length
);
2811 if (ntohs(oh
->auth_type
) != OSPF_AUTH_CRYPTOGRAPHIC
)
2814 if (oh
->u
.crypt
.auth_data_len
!= OSPF_AUTH_MD5_SIZE
) {
2815 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2817 "%s: unsupported crypto auth length (%u B)",
2818 __func__
, oh
->u
.crypt
.auth_data_len
);
2821 bytesauth
= OSPF_AUTH_MD5_SIZE
;
2823 if (bytesdeclared
+ bytesauth
> bytesonwire
) {
2824 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2826 "%s: packet length error (%u real, %u+%u declared)",
2827 __func__
, bytesonwire
, bytesdeclared
,
2831 /* Length, 2nd approximation. The type-specific constraint is checked
2832 against declared length, not amount of bytes on wire. */
2833 if (oh
->type
>= OSPF_MSG_HELLO
&& oh
->type
<= OSPF_MSG_LS_ACK
2835 < OSPF_HEADER_SIZE
+ ospf_packet_minlen
[oh
->type
]) {
2836 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2837 zlog_debug("%s: undersized (%u B) %s packet", __func__
,
2839 lookup_msg(ospf_packet_type_str
, oh
->type
,
2844 case OSPF_MSG_HELLO
:
2845 /* RFC2328 A.3.2, packet header + OSPF_HELLO_MIN_SIZE bytes
2847 by N>=0 router-IDs. */
2848 ret
= (bytesdeclared
- OSPF_HEADER_SIZE
- OSPF_HELLO_MIN_SIZE
)
2853 case OSPF_MSG_DB_DESC
:
2854 /* RFC2328 A.3.3, packet header + OSPF_DB_DESC_MIN_SIZE bytes
2856 by N>=0 header-only LSAs. */
2857 ret
= ospf_lsaseq_examin(
2858 (struct lsa_header
*)((caddr_t
)oh
+ OSPF_HEADER_SIZE
2859 + OSPF_DB_DESC_MIN_SIZE
),
2860 bytesdeclared
- OSPF_HEADER_SIZE
2861 - OSPF_DB_DESC_MIN_SIZE
,
2862 1, /* header-only LSAs */
2865 case OSPF_MSG_LS_REQ
:
2866 /* RFC2328 A.3.4, packet header followed by N>=0 12-bytes
2867 * request blocks. */
2868 ret
= (bytesdeclared
- OSPF_HEADER_SIZE
- OSPF_LS_REQ_MIN_SIZE
)
2873 case OSPF_MSG_LS_UPD
:
2874 /* RFC2328 A.3.5, packet header + OSPF_LS_UPD_MIN_SIZE bytes
2876 by N>=0 full LSAs (with N declared beforehand). */
2877 lsupd
= (struct ospf_ls_update
*)((caddr_t
)oh
2878 + OSPF_HEADER_SIZE
);
2879 ret
= ospf_lsaseq_examin(
2880 (struct lsa_header
*)((caddr_t
)lsupd
2881 + OSPF_LS_UPD_MIN_SIZE
),
2882 bytesdeclared
- OSPF_HEADER_SIZE
- OSPF_LS_UPD_MIN_SIZE
,
2884 ntohl(lsupd
->num_lsas
) /* 32 bits */
2887 case OSPF_MSG_LS_ACK
:
2888 /* RFC2328 A.3.6, packet header followed by N>=0 header-only
2890 ret
= ospf_lsaseq_examin(
2891 (struct lsa_header
*)((caddr_t
)oh
+ OSPF_HEADER_SIZE
2892 + OSPF_LS_ACK_MIN_SIZE
),
2893 bytesdeclared
- OSPF_HEADER_SIZE
- OSPF_LS_ACK_MIN_SIZE
,
2894 1, /* header-only LSAs */
2898 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2899 zlog_debug("%s: invalid packet type 0x%02x", __func__
,
2903 if (ret
!= MSG_OK
&& IS_DEBUG_OSPF_PACKET(0, RECV
))
2904 zlog_debug("%s: malformed %s packet", __func__
,
2905 lookup_msg(ospf_packet_type_str
, oh
->type
, NULL
));
2909 /* OSPF Header verification. */
2910 static int ospf_verify_header(struct stream
*ibuf
, struct ospf_interface
*oi
,
2911 struct ip
*iph
, struct ospf_header
*ospfh
)
2913 /* Check Area ID. */
2914 if (!ospf_check_area_id(oi
, ospfh
)) {
2915 flog_warn(EC_OSPF_PACKET
,
2916 "interface %s: ospf_read invalid Area ID %pI4",
2917 IF_NAME(oi
), &ospfh
->area_id
);
2921 /* Check network mask, Silently discarded. */
2922 if (!ospf_check_network_mask(oi
, iph
->ip_src
)) {
2925 "interface %s: ospf_read network address is not same [%pI4]",
2926 IF_NAME(oi
), &iph
->ip_src
);
2930 /* Check authentication. The function handles logging actions, where
2932 if (!ospf_check_auth(oi
, ospfh
))
2938 enum ospf_read_return_enum
{
2943 static enum ospf_read_return_enum
ospf_read_helper(struct ospf
*ospf
)
2946 struct stream
*ibuf
;
2947 struct ospf_interface
*oi
;
2949 struct ospf_header
*ospfh
;
2951 struct connected
*c
;
2952 struct interface
*ifp
= NULL
;
2954 stream_reset(ospf
->ibuf
);
2955 ibuf
= ospf_recv_packet(ospf
, ospf
->fd
, &ifp
, ospf
->ibuf
);
2957 return OSPF_READ_ERROR
;
2960 * This raw packet is known to be at least as big as its
2961 * IP header. Note that there should not be alignment problems with
2962 * this assignment because this is at the beginning of the
2963 * stream data buffer.
2965 iph
= (struct ip
*)STREAM_DATA(ibuf
);
2967 * Note that sockopt_iphdrincl_swab_systoh was called in
2972 * Handle cases where the platform does not support
2973 * retrieving the ifindex, and also platforms (such as
2974 * Solaris 8) that claim to support ifindex retrieval but do
2977 c
= if_lookup_address((void *)&iph
->ip_src
, AF_INET
,
2982 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
2984 "%s: Unable to determine incoming interface from: %pI4(%s)",
2985 __func__
, &iph
->ip_src
,
2986 ospf_get_name(ospf
));
2987 return OSPF_READ_CONTINUE
;
2991 if (ospf
->vrf_id
== VRF_DEFAULT
&& ospf
->vrf_id
!= ifp
->vrf_id
) {
2993 * We may have a situation where l3mdev_accept == 1
2994 * let's just kindly drop the packet and move on.
2995 * ospf really really really does not like when
2996 * we receive the same packet multiple times.
2998 return OSPF_READ_CONTINUE
;
3001 /* Self-originated packet should be discarded silently. */
3002 if (ospf_if_lookup_by_local_addr(ospf
, NULL
, iph
->ip_src
)) {
3003 if (IS_DEBUG_OSPF_PACKET(0, RECV
)) {
3005 "ospf_read[%pI4]: Dropping self-originated packet",
3008 return OSPF_READ_CONTINUE
;
3011 /* Check that we have enough for an IP header */
3012 if ((unsigned int)(iph
->ip_hl
<< 2) >= STREAM_READABLE(ibuf
)) {
3013 if ((unsigned int)(iph
->ip_hl
<< 2) == STREAM_READABLE(ibuf
)) {
3016 "Rx'd IP packet with OSPF protocol number but no payload");
3020 "IP header length field claims header is %u bytes, but we only have %zu",
3021 (unsigned int)(iph
->ip_hl
<< 2),
3022 STREAM_READABLE(ibuf
));
3025 return OSPF_READ_ERROR
;
3027 stream_forward_getp(ibuf
, iph
->ip_hl
<< 2);
3029 ospfh
= (struct ospf_header
*)stream_pnt(ibuf
);
3031 != ospf_packet_examin(ospfh
, stream_get_endp(ibuf
)
3032 - stream_get_getp(ibuf
)))
3033 return OSPF_READ_CONTINUE
;
3034 /* Now it is safe to access all fields of OSPF packet header. */
3036 /* associate packet with ospf interface */
3037 oi
= ospf_if_lookup_recv_if(ospf
, iph
->ip_src
, ifp
);
3040 * ospf_verify_header() relies on a valid "oi" and thus can be called
3041 * only after the passive/backbone/other checks below are passed.
3042 * These checks in turn access the fields of unverified "ospfh"
3043 * structure for their own purposes and must remain very accurate
3047 /* If incoming interface is passive one, ignore it. */
3048 if (oi
&& OSPF_IF_PASSIVE_STATUS(oi
) == OSPF_IF_PASSIVE
) {
3049 if (IS_DEBUG_OSPF_EVENT
)
3051 "ignoring packet from router %pI4 sent to %pI4, received on a passive interface, %pI4",
3052 &ospfh
->router_id
, &iph
->ip_dst
,
3053 &oi
->address
->u
.prefix4
);
3055 if (iph
->ip_dst
.s_addr
== htonl(OSPF_ALLSPFROUTERS
)) {
3056 /* Try to fix multicast membership.
3057 * Some OS:es may have problems in this area,
3058 * make sure it is removed.
3060 OI_MEMBER_JOINED(oi
, MEMBER_ALLROUTERS
);
3061 ospf_if_set_multicast(oi
);
3063 return OSPF_READ_CONTINUE
;
3067 /* if no local ospf_interface,
3068 * or header area is backbone but ospf_interface is not
3069 * check for VLINK interface
3072 || (OSPF_IS_AREA_ID_BACKBONE(ospfh
->area_id
)
3073 && !OSPF_IS_AREA_ID_BACKBONE(oi
->area
->area_id
))) {
3074 if ((oi
= ospf_associate_packet_vl(ospf
, ifp
, iph
, ospfh
))
3076 if (!ospf
->instance
&& IS_DEBUG_OSPF_EVENT
)
3078 "Packet from [%pI4] received on link %s but no ospf_interface",
3079 &iph
->ip_src
, ifp
->name
);
3080 return OSPF_READ_CONTINUE
;
3085 * else it must be a local ospf interface, check it was
3086 * received on correct link
3088 else if (oi
->ifp
!= ifp
) {
3089 if (IS_DEBUG_OSPF_EVENT
)
3090 flog_warn(EC_OSPF_PACKET
,
3091 "Packet from [%pI4] received on wrong link %s",
3092 &iph
->ip_src
, ifp
->name
);
3093 return OSPF_READ_CONTINUE
;
3094 } else if (oi
->state
== ISM_Down
) {
3097 "Ignoring packet from %pI4 to %pI4 received on interface that is down [%s]; interface flags are %s",
3098 &iph
->ip_src
, &iph
->ip_dst
, ifp
->name
,
3099 if_flag_dump(ifp
->flags
));
3100 /* Fix multicast memberships? */
3101 if (iph
->ip_dst
.s_addr
== htonl(OSPF_ALLSPFROUTERS
))
3102 OI_MEMBER_JOINED(oi
, MEMBER_ALLROUTERS
);
3103 else if (iph
->ip_dst
.s_addr
== htonl(OSPF_ALLDROUTERS
))
3104 OI_MEMBER_JOINED(oi
, MEMBER_DROUTERS
);
3105 if (oi
->multicast_memberships
)
3106 ospf_if_set_multicast(oi
);
3107 return OSPF_READ_CONTINUE
;
3111 * If the received packet is destined for AllDRouters, the
3112 * packet should be accepted only if the received ospf
3113 * interface state is either DR or Backup -- endo.
3115 * I wonder who endo is?
3117 if (iph
->ip_dst
.s_addr
== htonl(OSPF_ALLDROUTERS
)
3118 && (oi
->state
!= ISM_DR
&& oi
->state
!= ISM_Backup
)) {
3121 "Dropping packet for AllDRouters from [%pI4] via [%s] (ISM: %s)",
3122 &iph
->ip_src
, IF_NAME(oi
),
3123 lookup_msg(ospf_ism_state_msg
, oi
->state
, NULL
));
3124 /* Try to fix multicast membership. */
3125 SET_FLAG(oi
->multicast_memberships
, MEMBER_DROUTERS
);
3126 ospf_if_set_multicast(oi
);
3127 return OSPF_READ_CONTINUE
;
3130 /* Verify more OSPF header fields. */
3131 ret
= ospf_verify_header(ibuf
, oi
, iph
, ospfh
);
3133 if (IS_DEBUG_OSPF_PACKET(0, RECV
))
3135 "ospf_read[%pI4]: Header check failed, dropping.",
3137 return OSPF_READ_CONTINUE
;
3140 /* Show debug receiving packet. */
3141 if (IS_DEBUG_OSPF_PACKET(ospfh
->type
- 1, RECV
)) {
3142 if (IS_DEBUG_OSPF_PACKET(ospfh
->type
- 1, DETAIL
)) {
3144 "-----------------------------------------------------");
3145 ospf_packet_dump(ibuf
);
3148 zlog_debug("%s received from [%pI4] via [%s]",
3149 lookup_msg(ospf_packet_type_str
, ospfh
->type
, NULL
),
3150 &ospfh
->router_id
, IF_NAME(oi
));
3151 zlog_debug(" src [%pI4],", &iph
->ip_src
);
3152 zlog_debug(" dst [%pI4]", &iph
->ip_dst
);
3154 if (IS_DEBUG_OSPF_PACKET(ospfh
->type
- 1, DETAIL
))
3156 "-----------------------------------------------------");
3159 stream_forward_getp(ibuf
, OSPF_HEADER_SIZE
);
3161 /* Adjust size to message length. */
3162 length
= ntohs(ospfh
->length
) - OSPF_HEADER_SIZE
;
3164 /* Read rest of the packet and call each sort of packet routine.
3166 switch (ospfh
->type
) {
3167 case OSPF_MSG_HELLO
:
3168 ospf_hello(iph
, ospfh
, ibuf
, oi
, length
);
3170 case OSPF_MSG_DB_DESC
:
3171 ospf_db_desc(iph
, ospfh
, ibuf
, oi
, length
);
3173 case OSPF_MSG_LS_REQ
:
3174 ospf_ls_req(iph
, ospfh
, ibuf
, oi
, length
);
3176 case OSPF_MSG_LS_UPD
:
3177 ospf_ls_upd(ospf
, iph
, ospfh
, ibuf
, oi
, length
);
3179 case OSPF_MSG_LS_ACK
:
3180 ospf_ls_ack(iph
, ospfh
, ibuf
, oi
, length
);
3185 "interface %s(%s): OSPF packet header type %d is illegal",
3186 IF_NAME(oi
), ospf_get_name(ospf
), ospfh
->type
);
3190 return OSPF_READ_CONTINUE
;
3193 /* Starting point of packet process function. */
3194 int ospf_read(struct thread
*thread
)
3198 enum ospf_read_return_enum ret
;
3200 /* first of all get interface pointer. */
3201 ospf
= THREAD_ARG(thread
);
3203 /* prepare for next packet. */
3204 thread_add_read(master
, ospf_read
, ospf
, ospf
->fd
, &ospf
->t_read
);
3206 while (count
< ospf
->write_oi_count
) {
3208 ret
= ospf_read_helper(ospf
);
3210 case OSPF_READ_ERROR
:
3212 case OSPF_READ_CONTINUE
:
3220 /* Make OSPF header. */
3221 static void ospf_make_header(int type
, struct ospf_interface
*oi
,
3224 struct ospf_header
*ospfh
;
3226 ospfh
= (struct ospf_header
*)STREAM_DATA(s
);
3228 ospfh
->version
= (uint8_t)OSPF_VERSION
;
3229 ospfh
->type
= (uint8_t)type
;
3231 ospfh
->router_id
= oi
->ospf
->router_id
;
3233 ospfh
->checksum
= 0;
3234 ospfh
->area_id
= oi
->area
->area_id
;
3235 ospfh
->auth_type
= htons(ospf_auth_type(oi
));
3237 memset(ospfh
->u
.auth_data
, 0, OSPF_AUTH_SIMPLE_SIZE
);
3239 stream_forward_endp(s
, OSPF_HEADER_SIZE
);
3242 /* Make Authentication Data. */
3243 static int ospf_make_auth(struct ospf_interface
*oi
, struct ospf_header
*ospfh
)
3245 struct crypt_key
*ck
;
3247 switch (ospf_auth_type(oi
)) {
3248 case OSPF_AUTH_NULL
:
3249 /* memset (ospfh->u.auth_data, 0, sizeof(ospfh->u.auth_data));
3252 case OSPF_AUTH_SIMPLE
:
3253 memcpy(ospfh
->u
.auth_data
, OSPF_IF_PARAM(oi
, auth_simple
),
3254 OSPF_AUTH_SIMPLE_SIZE
);
3256 case OSPF_AUTH_CRYPTOGRAPHIC
:
3257 /* If key is not set, then set 0. */
3258 if (list_isempty(OSPF_IF_PARAM(oi
, auth_crypt
))) {
3259 ospfh
->u
.crypt
.zero
= 0;
3260 ospfh
->u
.crypt
.key_id
= 0;
3261 ospfh
->u
.crypt
.auth_data_len
= OSPF_AUTH_MD5_SIZE
;
3264 listtail(OSPF_IF_PARAM(oi
, auth_crypt
)));
3265 ospfh
->u
.crypt
.zero
= 0;
3266 ospfh
->u
.crypt
.key_id
= ck
->key_id
;
3267 ospfh
->u
.crypt
.auth_data_len
= OSPF_AUTH_MD5_SIZE
;
3269 /* note: the seq is done in ospf_make_md5_digest() */
3272 /* memset (ospfh->u.auth_data, 0, sizeof(ospfh->u.auth_data));
3280 /* Fill rest of OSPF header. */
3281 static void ospf_fill_header(struct ospf_interface
*oi
, struct stream
*s
,
3284 struct ospf_header
*ospfh
;
3286 ospfh
= (struct ospf_header
*)STREAM_DATA(s
);
3289 ospfh
->length
= htons(length
);
3291 /* Calculate checksum. */
3292 if (ntohs(ospfh
->auth_type
) != OSPF_AUTH_CRYPTOGRAPHIC
)
3293 ospfh
->checksum
= in_cksum(ospfh
, length
);
3295 ospfh
->checksum
= 0;
3297 /* Add Authentication Data. */
3298 ospf_make_auth(oi
, ospfh
);
3301 static int ospf_make_hello(struct ospf_interface
*oi
, struct stream
*s
)
3303 struct ospf_neighbor
*nbr
;
3304 struct route_node
*rn
;
3305 uint16_t length
= OSPF_HELLO_MIN_SIZE
;
3306 struct in_addr mask
;
3310 /* Set netmask of interface. */
3311 if (!(CHECK_FLAG(oi
->connected
->flags
, ZEBRA_IFA_UNNUMBERED
)
3312 && oi
->type
== OSPF_IFTYPE_POINTOPOINT
)
3313 && oi
->type
!= OSPF_IFTYPE_VIRTUALLINK
)
3314 masklen2ip(oi
->address
->prefixlen
, &mask
);
3316 memset((char *)&mask
, 0, sizeof(struct in_addr
));
3317 stream_put_ipv4(s
, mask
.s_addr
);
3319 /* Set Hello Interval. */
3320 if (OSPF_IF_PARAM(oi
, fast_hello
) == 0)
3321 stream_putw(s
, OSPF_IF_PARAM(oi
, v_hello
));
3323 stream_putw(s
, 0); /* hello-interval of 0 for fast-hellos */
3325 if (IS_DEBUG_OSPF_EVENT
)
3326 zlog_debug("make_hello: options: %x, int: %s", OPTIONS(oi
),
3330 stream_putc(s
, OPTIONS(oi
));
3332 /* Set Router Priority. */
3333 stream_putc(s
, PRIORITY(oi
));
3335 /* Set Router Dead Interval. */
3336 stream_putl(s
, OSPF_IF_PARAM(oi
, v_wait
));
3338 /* Set Designated Router. */
3339 stream_put_ipv4(s
, DR(oi
).s_addr
);
3341 p
= stream_get_endp(s
);
3343 /* Set Backup Designated Router. */
3344 stream_put_ipv4(s
, BDR(oi
).s_addr
);
3346 /* Add neighbor seen. */
3347 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
))
3348 if ((nbr
= rn
->info
))
3349 if (nbr
->router_id
.s_addr
3350 != INADDR_ANY
) /* Ignore 0.0.0.0 node. */
3352 != NSM_Attempt
) /* Ignore Down neighbor. */
3354 != NSM_Down
) /* This is myself for
3356 if (!IPV4_ADDR_SAME(
3358 &oi
->ospf
->router_id
)) {
3359 /* Check neighbor is
3361 if (nbr
->d_router
.s_addr
3375 /* Hello packet overflows interface MTU. */
3376 if (length
+ sizeof(uint32_t)
3377 > ospf_packet_max(oi
)) {
3379 EC_OSPF_LARGE_HELLO
,
3380 "Oversized Hello packet! Larger than MTU. Not sending it out");
3391 /* Let neighbor generate BackupSeen. */
3393 stream_putl_at(s
, p
, 0); /* ipv4 address, normally */
3398 static int ospf_make_db_desc(struct ospf_interface
*oi
,
3399 struct ospf_neighbor
*nbr
, struct stream
*s
)
3401 struct ospf_lsa
*lsa
;
3402 uint16_t length
= OSPF_DB_DESC_MIN_SIZE
;
3406 struct ospf_lsdb
*lsdb
;
3408 /* Set Interface MTU. */
3409 if (oi
->type
== OSPF_IFTYPE_VIRTUALLINK
)
3412 stream_putw(s
, oi
->ifp
->mtu
);
3415 options
= OPTIONS(oi
);
3416 if (CHECK_FLAG(oi
->ospf
->config
, OSPF_OPAQUE_CAPABLE
))
3417 SET_FLAG(options
, OSPF_OPTION_O
);
3418 stream_putc(s
, options
);
3421 pp
= stream_get_endp(s
);
3422 stream_putc(s
, nbr
->dd_flags
);
3424 /* Set DD Sequence Number. */
3425 stream_putl(s
, nbr
->dd_seqnum
);
3427 /* shortcut unneeded walk of (empty) summary LSDBs */
3428 if (ospf_db_summary_isempty(nbr
))
3431 /* Describe LSA Header from Database Summary List. */
3432 lsdb
= &nbr
->db_sum
;
3434 for (i
= OSPF_MIN_LSA
; i
< OSPF_MAX_LSA
; i
++) {
3435 struct route_table
*table
= lsdb
->type
[i
].db
;
3436 struct route_node
*rn
;
3438 for (rn
= route_top(table
); rn
; rn
= route_next(rn
))
3439 if ((lsa
= rn
->info
) != NULL
) {
3440 if (IS_OPAQUE_LSA(lsa
->data
->type
)
3441 && (!CHECK_FLAG(options
, OSPF_OPTION_O
))) {
3442 /* Suppress advertising
3443 * opaque-information. */
3444 /* Remove LSA from DB summary list. */
3445 ospf_lsdb_delete(lsdb
, lsa
);
3449 if (!CHECK_FLAG(lsa
->flags
, OSPF_LSA_DISCARD
)) {
3450 struct lsa_header
*lsah
;
3453 /* DD packet overflows interface MTU. */
3454 if (length
+ OSPF_LSA_HEADER_SIZE
3455 > ospf_packet_max(oi
))
3458 /* Keep pointer to LS age. */
3459 lsah
= (struct lsa_header
3464 /* Proceed stream pointer. */
3465 stream_put(s
, lsa
->data
,
3466 OSPF_LSA_HEADER_SIZE
);
3467 length
+= OSPF_LSA_HEADER_SIZE
;
3470 ls_age
= LS_AGE(lsa
);
3471 lsah
->ls_age
= htons(ls_age
);
3474 /* Remove LSA from DB summary list. */
3475 ospf_lsdb_delete(lsdb
, lsa
);
3479 /* Update 'More' bit */
3480 if (ospf_db_summary_isempty(nbr
)) {
3482 if (nbr
->state
>= NSM_Exchange
) {
3483 UNSET_FLAG(nbr
->dd_flags
, OSPF_DD_FLAG_M
);
3484 /* Rewrite DD flags */
3485 stream_putc_at(s
, pp
, nbr
->dd_flags
);
3487 assert(IS_SET_DD_M(nbr
->dd_flags
));
3493 static int ospf_make_ls_req_func(struct stream
*s
, uint16_t *length
,
3494 unsigned long delta
, struct ospf_neighbor
*nbr
,
3495 struct ospf_lsa
*lsa
)
3497 struct ospf_interface
*oi
;
3501 /* LS Request packet overflows interface MTU
3502 * delta is just number of bytes required for 1 LS Req
3503 * ospf_packet_max will return the number of bytes can
3504 * be accomodated without ospf header. So length+delta
3505 * can be compared to ospf_packet_max
3506 * to check if it can fit another lsreq in the same packet.
3509 if (*length
+ delta
> ospf_packet_max(oi
))
3512 stream_putl(s
, lsa
->data
->type
);
3513 stream_put_ipv4(s
, lsa
->data
->id
.s_addr
);
3514 stream_put_ipv4(s
, lsa
->data
->adv_router
.s_addr
);
3516 ospf_lsa_unlock(&nbr
->ls_req_last
);
3517 nbr
->ls_req_last
= ospf_lsa_lock(lsa
);
3523 static int ospf_make_ls_req(struct ospf_neighbor
*nbr
, struct stream
*s
)
3525 struct ospf_lsa
*lsa
;
3526 uint16_t length
= OSPF_LS_REQ_MIN_SIZE
;
3527 unsigned long delta
= 12;
3528 struct route_table
*table
;
3529 struct route_node
*rn
;
3531 struct ospf_lsdb
*lsdb
;
3533 lsdb
= &nbr
->ls_req
;
3535 for (i
= OSPF_MIN_LSA
; i
< OSPF_MAX_LSA
; i
++) {
3536 table
= lsdb
->type
[i
].db
;
3537 for (rn
= route_top(table
); rn
; rn
= route_next(rn
))
3538 if ((lsa
= (rn
->info
)) != NULL
)
3539 if (ospf_make_ls_req_func(s
, &length
, delta
,
3542 route_unlock_node(rn
);
3549 static int ls_age_increment(struct ospf_lsa
*lsa
, int delay
)
3553 age
= IS_LSA_MAXAGE(lsa
) ? OSPF_LSA_MAXAGE
: LS_AGE(lsa
) + delay
;
3555 return (age
> OSPF_LSA_MAXAGE
? OSPF_LSA_MAXAGE
: age
);
3558 static int ospf_make_ls_upd(struct ospf_interface
*oi
, struct list
*update
,
3561 struct ospf_lsa
*lsa
;
3562 struct listnode
*node
;
3563 uint16_t length
= 0;
3564 unsigned int size_noauth
;
3565 unsigned long delta
= stream_get_endp(s
);
3569 if (IS_DEBUG_OSPF_EVENT
)
3570 zlog_debug("ospf_make_ls_upd: Start");
3572 pp
= stream_get_endp(s
);
3573 stream_forward_endp(s
, OSPF_LS_UPD_MIN_SIZE
);
3574 length
+= OSPF_LS_UPD_MIN_SIZE
;
3576 /* Calculate amount of packet usable for data. */
3577 size_noauth
= stream_get_size(s
) - ospf_packet_authspace(oi
);
3579 while ((node
= listhead(update
)) != NULL
) {
3580 struct lsa_header
*lsah
;
3583 lsa
= listgetdata(node
);
3586 if (IS_DEBUG_OSPF_EVENT
)
3587 zlog_debug("%s: List Iteration %d LSA[%s]", __func__
,
3588 count
, dump_lsa_key(lsa
));
3590 /* Will it fit? Minimum it has to fit atleast one */
3591 if ((length
+ delta
+ ntohs(lsa
->data
->length
) > size_noauth
) &&
3595 /* Keep pointer to LS age. */
3596 lsah
= (struct lsa_header
*)(STREAM_DATA(s
)
3597 + stream_get_endp(s
));
3599 /* Put LSA to Link State Request. */
3600 stream_put(s
, lsa
->data
, ntohs(lsa
->data
->length
));
3603 /* each hop must increment an lsa_age by transmit_delay
3604 of OSPF interface */
3605 ls_age
= ls_age_increment(lsa
,
3606 OSPF_IF_PARAM(oi
, transmit_delay
));
3607 lsah
->ls_age
= htons(ls_age
);
3609 length
+= ntohs(lsa
->data
->length
);
3612 list_delete_node(update
, node
);
3613 ospf_lsa_unlock(&lsa
); /* oi->ls_upd_queue */
3616 /* Now set #LSAs. */
3617 stream_putl_at(s
, pp
, count
);
3619 if (IS_DEBUG_OSPF_EVENT
)
3620 zlog_debug("ospf_make_ls_upd: Stop");
3624 static int ospf_make_ls_ack(struct ospf_interface
*oi
, struct list
*ack
,
3627 struct listnode
*node
, *nnode
;
3628 uint16_t length
= OSPF_LS_ACK_MIN_SIZE
;
3629 unsigned long delta
= OSPF_LSA_HEADER_SIZE
;
3630 struct ospf_lsa
*lsa
;
3632 for (ALL_LIST_ELEMENTS(ack
, node
, nnode
, lsa
)) {
3635 /* LS Ack packet overflows interface MTU
3636 * delta is just number of bytes required for
3637 * 1 LS Ack(1 LS Hdr) ospf_packet_max will return
3638 * the number of bytes can be accomodated without
3639 * ospf header. So length+delta can be compared
3640 * against ospf_packet_max to check if it can fit
3641 * another ls header in the same packet.
3643 if ((length
+ delta
) > ospf_packet_max(oi
))
3646 stream_put(s
, lsa
->data
, OSPF_LSA_HEADER_SIZE
);
3647 length
+= OSPF_LSA_HEADER_SIZE
;
3649 listnode_delete(ack
, lsa
);
3650 ospf_lsa_unlock(&lsa
); /* oi->ls_ack_direct.ls_ack */
3656 static void ospf_hello_send_sub(struct ospf_interface
*oi
, in_addr_t addr
)
3658 struct ospf_packet
*op
;
3659 uint16_t length
= OSPF_HEADER_SIZE
;
3661 op
= ospf_packet_new(oi
->ifp
->mtu
);
3663 /* Prepare OSPF common header. */
3664 ospf_make_header(OSPF_MSG_HELLO
, oi
, op
->s
);
3666 /* Prepare OSPF Hello body. */
3667 length
+= ospf_make_hello(oi
, op
->s
);
3668 if (length
== OSPF_HEADER_SIZE
) {
3669 /* Hello overshooting MTU */
3670 ospf_packet_free(op
);
3674 /* Fill OSPF header. */
3675 ospf_fill_header(oi
, op
->s
, length
);
3677 /* Set packet length. */
3678 op
->length
= length
;
3680 op
->dst
.s_addr
= addr
;
3682 if (IS_DEBUG_OSPF_EVENT
) {
3683 if (oi
->ospf
->vrf_id
)
3685 "%s: Hello Tx interface %s ospf vrf %s id %u",
3686 __func__
, oi
->ifp
->name
,
3687 ospf_vrf_id_to_name(oi
->ospf
->vrf_id
),
3690 /* Add packet to the top of the interface output queue, so that they
3691 * can't get delayed by things like long queues of LS Update packets
3693 ospf_packet_add_top(oi
, op
);
3695 /* Hook thread to write packet. */
3696 OSPF_ISM_WRITE_ON(oi
->ospf
);
3699 static void ospf_poll_send(struct ospf_nbr_nbma
*nbr_nbma
)
3701 struct ospf_interface
*oi
;
3706 /* If this is passive interface, do not send OSPF Hello. */
3707 if (OSPF_IF_PASSIVE_STATUS(oi
) == OSPF_IF_PASSIVE
)
3710 if (oi
->type
!= OSPF_IFTYPE_NBMA
)
3713 if (nbr_nbma
->nbr
!= NULL
&& nbr_nbma
->nbr
->state
!= NSM_Down
)
3716 if (PRIORITY(oi
) == 0)
3719 if (nbr_nbma
->priority
== 0 && oi
->state
!= ISM_DR
3720 && oi
->state
!= ISM_Backup
)
3723 ospf_hello_send_sub(oi
, nbr_nbma
->addr
.s_addr
);
3726 int ospf_poll_timer(struct thread
*thread
)
3728 struct ospf_nbr_nbma
*nbr_nbma
;
3730 nbr_nbma
= THREAD_ARG(thread
);
3731 nbr_nbma
->t_poll
= NULL
;
3733 if (IS_DEBUG_OSPF(nsm
, NSM_TIMERS
))
3734 zlog_debug("NSM[%s:%pI4]: Timer (Poll timer expire)",
3735 IF_NAME(nbr_nbma
->oi
), &nbr_nbma
->addr
);
3737 ospf_poll_send(nbr_nbma
);
3739 if (nbr_nbma
->v_poll
> 0)
3740 OSPF_POLL_TIMER_ON(nbr_nbma
->t_poll
, ospf_poll_timer
,
3747 int ospf_hello_reply_timer(struct thread
*thread
)
3749 struct ospf_neighbor
*nbr
;
3751 nbr
= THREAD_ARG(thread
);
3752 nbr
->t_hello_reply
= NULL
;
3754 if (IS_DEBUG_OSPF(nsm
, NSM_TIMERS
))
3755 zlog_debug("NSM[%s:%pI4]: Timer (hello-reply timer expire)",
3756 IF_NAME(nbr
->oi
), &nbr
->router_id
);
3758 ospf_hello_send_sub(nbr
->oi
, nbr
->address
.u
.prefix4
.s_addr
);
3763 /* Send OSPF Hello. */
3764 void ospf_hello_send(struct ospf_interface
*oi
)
3766 /* If this is passive interface, do not send OSPF Hello. */
3767 if (OSPF_IF_PASSIVE_STATUS(oi
) == OSPF_IF_PASSIVE
)
3770 if (oi
->type
== OSPF_IFTYPE_NBMA
) {
3771 struct ospf_neighbor
*nbr
;
3772 struct route_node
*rn
;
3774 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
))
3775 if ((nbr
= rn
->info
))
3776 if (nbr
!= oi
->nbr_self
)
3777 if (nbr
->state
!= NSM_Down
) {
3778 /* RFC 2328 Section 9.5.1
3779 If the router is not
3780 eligible to become Designated
3782 it must periodically send
3783 Hello Packets to both the
3784 Designated Router and the
3785 Backup Designated Router (if
3788 if (PRIORITY(oi
) == 0
3799 /* If the router is eligible to
3800 become Designated Router, it
3801 must periodically send Hello
3802 Packets to all neighbors that
3803 are also eligible. In
3804 addition, if the router is
3806 Designated Router or Backup
3807 Designated Router, it must
3809 send periodic Hello Packets
3810 to all other neighbors. */
3812 if (nbr
->priority
== 0
3813 && oi
->state
== ISM_DROther
)
3815 /* if oi->state == Waiting, send
3816 * hello to all neighbors */
3817 ospf_hello_send_sub(
3819 nbr
->address
.u
.prefix4
3823 /* Decide destination address. */
3824 if (oi
->type
== OSPF_IFTYPE_VIRTUALLINK
)
3825 ospf_hello_send_sub(oi
, oi
->vl_data
->peer_addr
.s_addr
);
3827 ospf_hello_send_sub(oi
, htonl(OSPF_ALLSPFROUTERS
));
3831 /* Send OSPF Database Description. */
3832 void ospf_db_desc_send(struct ospf_neighbor
*nbr
)
3834 struct ospf_interface
*oi
;
3835 struct ospf_packet
*op
;
3836 uint16_t length
= OSPF_HEADER_SIZE
;
3839 op
= ospf_packet_new(oi
->ifp
->mtu
);
3841 /* Prepare OSPF common header. */
3842 ospf_make_header(OSPF_MSG_DB_DESC
, oi
, op
->s
);
3844 /* Prepare OSPF Database Description body. */
3845 length
+= ospf_make_db_desc(oi
, nbr
, op
->s
);
3847 /* Fill OSPF header. */
3848 ospf_fill_header(oi
, op
->s
, length
);
3850 /* Set packet length. */
3851 op
->length
= length
;
3853 /* Decide destination address. */
3854 if (oi
->type
== OSPF_IFTYPE_POINTOPOINT
)
3855 op
->dst
.s_addr
= htonl(OSPF_ALLSPFROUTERS
);
3857 op
->dst
= nbr
->address
.u
.prefix4
;
3859 /* Add packet to the interface output queue. */
3860 ospf_packet_add(oi
, op
);
3862 /* Hook thread to write packet. */
3863 OSPF_ISM_WRITE_ON(oi
->ospf
);
3865 /* Remove old DD packet, then copy new one and keep in neighbor
3868 ospf_packet_free(nbr
->last_send
);
3869 nbr
->last_send
= ospf_packet_dup(op
);
3870 monotime(&nbr
->last_send_ts
);
3871 if (CHECK_FLAG(oi
->ospf
->config
, OSPF_LOG_ADJACENCY_DETAIL
))
3873 "%s:Packet[DD]: %pI4 DB Desc send with seqnum:%x , flags:%x",
3874 (oi
->ospf
->name
) ? oi
->ospf
->name
: VRF_DEFAULT_NAME
,
3875 &nbr
->router_id
, nbr
->dd_seqnum
,
3879 /* Re-send Database Description. */
3880 void ospf_db_desc_resend(struct ospf_neighbor
*nbr
)
3882 struct ospf_interface
*oi
;
3886 /* Add packet to the interface output queue. */
3887 ospf_packet_add(oi
, ospf_packet_dup(nbr
->last_send
));
3889 /* Hook thread to write packet. */
3890 OSPF_ISM_WRITE_ON(oi
->ospf
);
3891 if (CHECK_FLAG(oi
->ospf
->config
, OSPF_LOG_ADJACENCY_DETAIL
))
3893 "%s:Packet[DD]: %pI4 DB Desc resend with seqnum:%x , flags:%x",
3894 (oi
->ospf
->name
) ? oi
->ospf
->name
: VRF_DEFAULT_NAME
,
3895 &nbr
->router_id
, nbr
->dd_seqnum
,
3899 /* Send Link State Request. */
3900 void ospf_ls_req_send(struct ospf_neighbor
*nbr
)
3902 struct ospf_interface
*oi
;
3903 struct ospf_packet
*op
;
3904 uint16_t length
= OSPF_HEADER_SIZE
;
3907 op
= ospf_packet_new(oi
->ifp
->mtu
);
3909 /* Prepare OSPF common header. */
3910 ospf_make_header(OSPF_MSG_LS_REQ
, oi
, op
->s
);
3912 /* Prepare OSPF Link State Request body. */
3913 length
+= ospf_make_ls_req(nbr
, op
->s
);
3914 if (length
== OSPF_HEADER_SIZE
) {
3915 ospf_packet_free(op
);
3919 /* Fill OSPF header. */
3920 ospf_fill_header(oi
, op
->s
, length
);
3922 /* Set packet length. */
3923 op
->length
= length
;
3925 /* Decide destination address. */
3926 if (oi
->type
== OSPF_IFTYPE_POINTOPOINT
)
3927 op
->dst
.s_addr
= htonl(OSPF_ALLSPFROUTERS
);
3929 op
->dst
= nbr
->address
.u
.prefix4
;
3931 /* Add packet to the interface output queue. */
3932 ospf_packet_add(oi
, op
);
3934 /* Hook thread to write packet. */
3935 OSPF_ISM_WRITE_ON(oi
->ospf
);
3937 /* Add Link State Request Retransmission Timer. */
3938 OSPF_NSM_TIMER_ON(nbr
->t_ls_req
, ospf_ls_req_timer
, nbr
->v_ls_req
);
3941 /* Send Link State Update with an LSA. */
3942 void ospf_ls_upd_send_lsa(struct ospf_neighbor
*nbr
, struct ospf_lsa
*lsa
,
3945 struct list
*update
;
3947 update
= list_new();
3949 listnode_add(update
, lsa
);
3951 /*ospf instance is going down, send self originated
3952 * MAXAGE LSA update to neighbors to remove from LSDB */
3953 if (nbr
->oi
->ospf
->inst_shutdown
&& IS_LSA_MAXAGE(lsa
))
3954 ospf_ls_upd_send(nbr
, update
, flag
, 1);
3956 ospf_ls_upd_send(nbr
, update
, flag
, 0);
3958 list_delete(&update
);
3961 /* Determine size for packet. Must be at least big enough to accomodate next
3962 * LSA on list, which may be bigger than MTU size.
3964 * Return pointer to new ospf_packet
3965 * NULL if we can not allocate, eg because LSA is bigger than imposed limit
3966 * on packet sizes (in which case offending LSA is deleted from update list)
3968 static struct ospf_packet
*ospf_ls_upd_packet_new(struct list
*update
,
3969 struct ospf_interface
*oi
)
3971 struct ospf_lsa
*lsa
;
3972 struct listnode
*ln
;
3974 static char warned
= 0;
3976 lsa
= listgetdata((ln
= listhead(update
)));
3979 if ((OSPF_LS_UPD_MIN_SIZE
+ ntohs(lsa
->data
->length
))
3980 > ospf_packet_max(oi
)) {
3984 "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 ..'");
3988 if (IS_DEBUG_OSPF_PACKET(0, SEND
))
3990 "ospf_ls_upd_packet_new: oversized LSA id:%pI4, %d bytes originated by %pI4, will be fragmented!",
3992 ntohs(lsa
->data
->length
),
3993 &lsa
->data
->adv_router
);
3996 * Allocate just enough to fit this LSA only, to avoid including
3998 * LSAs in fragmented LSA Updates.
4000 size
= ntohs(lsa
->data
->length
)
4001 + (oi
->ifp
->mtu
- ospf_packet_max(oi
))
4002 + OSPF_LS_UPD_MIN_SIZE
;
4004 size
= oi
->ifp
->mtu
;
4006 if (size
> OSPF_MAX_PACKET_SIZE
) {
4007 flog_warn(EC_OSPF_LARGE_LSA
,
4008 "ospf_ls_upd_packet_new: oversized LSA id:%pI4 too big, %d bytes, packet size %ld, dropping it completely. OSPF routing is broken!",
4009 &lsa
->data
->id
, ntohs(lsa
->data
->length
),
4011 list_delete_node(update
, ln
);
4015 /* IP header is built up separately by ospf_write(). This means, that we
4017 * reduce the "affordable" size just calculated by length of an IP
4019 * This makes sure, that even if we manage to fill the payload with LSA
4021 * completely, the final packet (our data plus IP header) still fits
4023 * outgoing interface MTU. This correction isn't really meaningful for
4025 * oversized LSA, but for consistency the correction is done for both
4028 * P.S. OSPF_MAX_PACKET_SIZE above already includes IP header size
4030 return ospf_packet_new(size
- sizeof(struct ip
));
4033 static void ospf_ls_upd_queue_send(struct ospf_interface
*oi
,
4034 struct list
*update
, struct in_addr addr
,
4037 struct ospf_packet
*op
;
4038 uint16_t length
= OSPF_HEADER_SIZE
;
4040 if (IS_DEBUG_OSPF_EVENT
)
4041 zlog_debug("listcount = %d, [%s]dst %pI4", listcount(update
),
4042 IF_NAME(oi
), &addr
);
4044 /* Check that we have really something to process */
4045 if (listcount(update
) == 0)
4048 op
= ospf_ls_upd_packet_new(update
, oi
);
4050 /* Prepare OSPF common header. */
4051 ospf_make_header(OSPF_MSG_LS_UPD
, oi
, op
->s
);
4053 /* Prepare OSPF Link State Update body.
4054 * Includes Type-7 translation.
4056 length
+= ospf_make_ls_upd(oi
, update
, op
->s
);
4058 /* Fill OSPF header. */
4059 ospf_fill_header(oi
, op
->s
, length
);
4061 /* Set packet length. */
4062 op
->length
= length
;
4064 /* Decide destination address. */
4065 if (oi
->type
== OSPF_IFTYPE_POINTOPOINT
)
4066 op
->dst
.s_addr
= htonl(OSPF_ALLSPFROUTERS
);
4068 op
->dst
.s_addr
= addr
.s_addr
;
4070 /* Add packet to the interface output queue. */
4071 ospf_packet_add(oi
, op
);
4072 /* Call ospf_write() right away to send ospf packets to neighbors */
4073 if (send_lsupd_now
) {
4074 struct thread os_packet_thd
;
4076 os_packet_thd
.arg
= (void *)oi
->ospf
;
4077 if (oi
->on_write_q
== 0) {
4078 listnode_add(oi
->ospf
->oi_write_q
, oi
);
4081 ospf_write(&os_packet_thd
);
4083 * We are fake calling ospf_write with a fake
4084 * thread. Imagine that we have oi_a already
4085 * enqueued and we have turned on the write
4087 * Now this function calls this for oi_b
4088 * so the on_write_q has oi_a and oi_b on
4089 * it, ospf_write runs and clears the packets
4090 * for both oi_a and oi_b. Removing them from
4091 * the on_write_q. After this thread of execution
4092 * finishes we will execute the t_write thread
4093 * with nothing in the on_write_q causing an
4094 * assert. So just make sure that the t_write
4095 * is actually turned off.
4097 if (list_isempty(oi
->ospf
->oi_write_q
))
4098 OSPF_TIMER_OFF(oi
->ospf
->t_write
);
4100 /* Hook thread to write packet. */
4101 OSPF_ISM_WRITE_ON(oi
->ospf
);
4105 static int ospf_ls_upd_send_queue_event(struct thread
*thread
)
4107 struct ospf_interface
*oi
= THREAD_ARG(thread
);
4108 struct route_node
*rn
;
4109 struct route_node
*rnext
;
4110 struct list
*update
;
4113 oi
->t_ls_upd_event
= NULL
;
4115 if (IS_DEBUG_OSPF_EVENT
)
4116 zlog_debug("ospf_ls_upd_send_queue start");
4118 for (rn
= route_top(oi
->ls_upd_queue
); rn
; rn
= rnext
) {
4119 rnext
= route_next(rn
);
4121 if (rn
->info
== NULL
)
4124 update
= (struct list
*)rn
->info
;
4126 ospf_ls_upd_queue_send(oi
, update
, rn
->p
.u
.prefix4
, 0);
4128 /* list might not be empty. */
4129 if (listcount(update
) == 0) {
4130 list_delete((struct list
**)&rn
->info
);
4131 route_unlock_node(rn
);
4137 if (IS_DEBUG_OSPF_EVENT
)
4139 "ospf_ls_upd_send_queue: update lists not cleared, %d nodes to try again, raising new event",
4141 oi
->t_ls_upd_event
= NULL
;
4142 thread_add_event(master
, ospf_ls_upd_send_queue_event
, oi
, 0,
4143 &oi
->t_ls_upd_event
);
4146 if (IS_DEBUG_OSPF_EVENT
)
4147 zlog_debug("ospf_ls_upd_send_queue stop");
4152 void ospf_ls_upd_send(struct ospf_neighbor
*nbr
, struct list
*update
, int flag
,
4155 struct ospf_interface
*oi
;
4156 struct ospf_lsa
*lsa
;
4157 struct prefix_ipv4 p
;
4158 struct route_node
*rn
;
4159 struct listnode
*node
;
4164 p
.prefixlen
= IPV4_MAX_BITLEN
;
4166 /* Decide destination address. */
4167 if (oi
->type
== OSPF_IFTYPE_VIRTUALLINK
)
4168 p
.prefix
= oi
->vl_data
->peer_addr
;
4169 else if (oi
->type
== OSPF_IFTYPE_POINTOPOINT
)
4170 p
.prefix
.s_addr
= htonl(OSPF_ALLSPFROUTERS
);
4171 else if (flag
== OSPF_SEND_PACKET_DIRECT
)
4172 p
.prefix
= nbr
->address
.u
.prefix4
;
4173 else if (oi
->state
== ISM_DR
|| oi
->state
== ISM_Backup
)
4174 p
.prefix
.s_addr
= htonl(OSPF_ALLSPFROUTERS
);
4175 else if (oi
->type
== OSPF_IFTYPE_POINTOMULTIPOINT
)
4176 p
.prefix
.s_addr
= htonl(OSPF_ALLSPFROUTERS
);
4178 p
.prefix
.s_addr
= htonl(OSPF_ALLDROUTERS
);
4180 if (oi
->type
== OSPF_IFTYPE_NBMA
) {
4181 if (flag
== OSPF_SEND_PACKET_INDIRECT
)
4184 "* LS-Update is directly sent on NBMA network.");
4185 if (IPV4_ADDR_SAME(&oi
->address
->u
.prefix4
, &p
.prefix
))
4186 flog_warn(EC_OSPF_PACKET
,
4187 "* LS-Update is sent to myself.");
4190 rn
= route_node_get(oi
->ls_upd_queue
, (struct prefix
*)&p
);
4192 if (rn
->info
== NULL
)
4193 rn
->info
= list_new();
4195 route_unlock_node(rn
);
4197 for (ALL_LIST_ELEMENTS_RO(update
, node
, lsa
))
4198 listnode_add(rn
->info
,
4199 ospf_lsa_lock(lsa
)); /* oi->ls_upd_queue */
4200 if (send_lsupd_now
) {
4201 struct list
*send_update_list
;
4202 struct route_node
*rnext
;
4204 for (rn
= route_top(oi
->ls_upd_queue
); rn
; rn
= rnext
) {
4205 rnext
= route_next(rn
);
4207 if (rn
->info
== NULL
)
4210 send_update_list
= (struct list
*)rn
->info
;
4212 ospf_ls_upd_queue_send(oi
, send_update_list
,
4213 rn
->p
.u
.prefix4
, 1);
4216 thread_add_event(master
, ospf_ls_upd_send_queue_event
, oi
, 0,
4217 &oi
->t_ls_upd_event
);
4220 static void ospf_ls_ack_send_list(struct ospf_interface
*oi
, struct list
*ack
,
4223 struct ospf_packet
*op
;
4224 uint16_t length
= OSPF_HEADER_SIZE
;
4226 op
= ospf_packet_new(oi
->ifp
->mtu
);
4228 /* Prepare OSPF common header. */
4229 ospf_make_header(OSPF_MSG_LS_ACK
, oi
, op
->s
);
4231 /* Prepare OSPF Link State Acknowledgment body. */
4232 length
+= ospf_make_ls_ack(oi
, ack
, op
->s
);
4234 /* Fill OSPF header. */
4235 ospf_fill_header(oi
, op
->s
, length
);
4237 /* Set packet length. */
4238 op
->length
= length
;
4240 /* Decide destination address. */
4241 if (oi
->type
== OSPF_IFTYPE_POINTOPOINT
)
4242 op
->dst
.s_addr
= htonl(OSPF_ALLSPFROUTERS
);
4244 op
->dst
.s_addr
= dst
.s_addr
;
4246 /* Add packet to the interface output queue. */
4247 ospf_packet_add(oi
, op
);
4249 /* Hook thread to write packet. */
4250 OSPF_ISM_WRITE_ON(oi
->ospf
);
4253 static int ospf_ls_ack_send_event(struct thread
*thread
)
4255 struct ospf_interface
*oi
= THREAD_ARG(thread
);
4257 oi
->t_ls_ack_direct
= NULL
;
4259 while (listcount(oi
->ls_ack_direct
.ls_ack
))
4260 ospf_ls_ack_send_list(oi
, oi
->ls_ack_direct
.ls_ack
,
4261 oi
->ls_ack_direct
.dst
);
4266 void ospf_ls_ack_send(struct ospf_neighbor
*nbr
, struct ospf_lsa
*lsa
)
4268 struct ospf_interface
*oi
= nbr
->oi
;
4270 if (IS_GRACE_LSA(lsa
)) {
4271 if (IS_DEBUG_OSPF_GR
)
4272 zlog_debug("%s, Sending GRACE ACK to Restarter.",
4276 if (listcount(oi
->ls_ack_direct
.ls_ack
) == 0)
4277 oi
->ls_ack_direct
.dst
= nbr
->address
.u
.prefix4
;
4279 listnode_add(oi
->ls_ack_direct
.ls_ack
, ospf_lsa_lock(lsa
));
4281 thread_add_event(master
, ospf_ls_ack_send_event
, oi
, 0,
4282 &oi
->t_ls_ack_direct
);
4285 /* Send Link State Acknowledgment delayed. */
4286 void ospf_ls_ack_send_delayed(struct ospf_interface
*oi
)
4290 /* Decide destination address. */
4291 /* RFC2328 Section 13.5 On non-broadcast
4292 networks, delayed Link State Acknowledgment packets must be
4293 unicast separately over each adjacency (i.e., neighbor whose
4294 state is >= Exchange). */
4295 if (oi
->type
== OSPF_IFTYPE_NBMA
) {
4296 struct ospf_neighbor
*nbr
;
4297 struct route_node
*rn
;
4299 for (rn
= route_top(oi
->nbrs
); rn
; rn
= route_next(rn
))
4300 if ((nbr
= rn
->info
) != NULL
)
4301 if (nbr
!= oi
->nbr_self
4302 && nbr
->state
>= NSM_Exchange
)
4303 while (listcount(oi
->ls_ack
))
4304 ospf_ls_ack_send_list(
4306 nbr
->address
.u
.prefix4
);
4309 if (oi
->type
== OSPF_IFTYPE_VIRTUALLINK
)
4310 dst
.s_addr
= oi
->vl_data
->peer_addr
.s_addr
;
4311 else if (oi
->state
== ISM_DR
|| oi
->state
== ISM_Backup
)
4312 dst
.s_addr
= htonl(OSPF_ALLSPFROUTERS
);
4313 else if (oi
->type
== OSPF_IFTYPE_POINTOPOINT
)
4314 dst
.s_addr
= htonl(OSPF_ALLSPFROUTERS
);
4315 else if (oi
->type
== OSPF_IFTYPE_POINTOMULTIPOINT
)
4316 dst
.s_addr
= htonl(OSPF_ALLSPFROUTERS
);
4318 dst
.s_addr
= htonl(OSPF_ALLDROUTERS
);
4320 while (listcount(oi
->ls_ack
))
4321 ospf_ls_ack_send_list(oi
, oi
->ls_ack
, dst
);
4325 * On pt-to-pt links, all OSPF control packets are sent to the multicast
4326 * address. As a result, the kernel does not need to learn the interface
4327 * MAC of the OSPF neighbor. However, in our world, this will delay
4328 * convergence. Take the case when due to a link flap, all routes now
4329 * want to use an interface which was deemed to be costlier prior to this
4330 * event. For routes that will be installed, the missing MAC will have
4331 * punt-to-CPU set on them. This may overload the CPU control path that
4332 * can be avoided if the MAC was known apriori.
4334 void ospf_proactively_arp(struct ospf_neighbor
*nbr
)
4336 if (!nbr
|| !nbr
->oi
->ospf
->proactive_arp
)
4339 ospf_zebra_send_arp(nbr
->oi
->ifp
, &nbr
->address
);