]> git.proxmox.com Git - mirror_frr.git/blob - ospf6d/ospf6_message.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #1955 from qlyoung/stylechecker
[mirror_frr.git] / ospf6d / ospf6_message.c
1 /*
2 * Copyright (C) 2003 Yasuhiro Ohara
3 *
4 * This file is part of GNU Zebra.
5 *
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
9 * later version.
10 *
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <zebra.h>
22
23 #include "memory.h"
24 #include "log.h"
25 #include "vty.h"
26 #include "command.h"
27 #include "thread.h"
28 #include "linklist.h"
29
30 #include "ospf6_proto.h"
31 #include "ospf6_lsa.h"
32 #include "ospf6_lsdb.h"
33 #include "ospf6_network.h"
34 #include "ospf6_message.h"
35
36 #include "ospf6_top.h"
37 #include "ospf6_area.h"
38 #include "ospf6_neighbor.h"
39 #include "ospf6_interface.h"
40
41 /* for structures and macros ospf6_lsa_examin() needs */
42 #include "ospf6_abr.h"
43 #include "ospf6_asbr.h"
44 #include "ospf6_intra.h"
45
46 #include "ospf6_flood.h"
47 #include "ospf6d.h"
48
49 #include <netinet/ip6.h>
50
51 unsigned char conf_debug_ospf6_message[6] = {0x03, 0, 0, 0, 0, 0};
52 static const struct message ospf6_message_type_str[] = {
53 {OSPF6_MESSAGE_TYPE_HELLO, "Hello"},
54 {OSPF6_MESSAGE_TYPE_DBDESC, "DbDesc"},
55 {OSPF6_MESSAGE_TYPE_LSREQ, "LSReq"},
56 {OSPF6_MESSAGE_TYPE_LSUPDATE, "LSUpdate"},
57 {OSPF6_MESSAGE_TYPE_LSACK, "LSAck"},
58 {0}};
59
60 /* Minimum (besides the standard OSPF packet header) lengths for OSPF
61 packets of particular types, offset is the "type" field. */
62 const uint16_t ospf6_packet_minlen[OSPF6_MESSAGE_TYPE_ALL] = {
63 0,
64 OSPF6_HELLO_MIN_SIZE,
65 OSPF6_DB_DESC_MIN_SIZE,
66 OSPF6_LS_REQ_MIN_SIZE,
67 OSPF6_LS_UPD_MIN_SIZE,
68 OSPF6_LS_ACK_MIN_SIZE};
69
70 /* Minimum (besides the standard LSA header) lengths for LSAs of particular
71 types, offset is the "LSA function code" portion of "LSA type" field. */
72 const uint16_t ospf6_lsa_minlen[OSPF6_LSTYPE_SIZE] = {
73 0,
74 /* 0x2001 */ OSPF6_ROUTER_LSA_MIN_SIZE,
75 /* 0x2002 */ OSPF6_NETWORK_LSA_MIN_SIZE,
76 /* 0x2003 */ OSPF6_INTER_PREFIX_LSA_MIN_SIZE,
77 /* 0x2004 */ OSPF6_INTER_ROUTER_LSA_FIX_SIZE,
78 /* 0x4005 */ OSPF6_AS_EXTERNAL_LSA_MIN_SIZE,
79 /* 0x2006 */ 0,
80 /* 0x2007 */ OSPF6_AS_EXTERNAL_LSA_MIN_SIZE,
81 /* 0x0008 */ OSPF6_LINK_LSA_MIN_SIZE,
82 /* 0x2009 */ OSPF6_INTRA_PREFIX_LSA_MIN_SIZE};
83
84 /* print functions */
85
86 static void ospf6_header_print(struct ospf6_header *oh)
87 {
88 char router_id[16], area_id[16];
89 inet_ntop(AF_INET, &oh->router_id, router_id, sizeof(router_id));
90 inet_ntop(AF_INET, &oh->area_id, area_id, sizeof(area_id));
91
92 zlog_debug(" OSPFv%d Type:%d Len:%hu Router-ID:%s", oh->version,
93 oh->type, ntohs(oh->length), router_id);
94 zlog_debug(" Area-ID:%s Cksum:%hx Instance-ID:%d", area_id,
95 ntohs(oh->checksum), oh->instance_id);
96 }
97
98 void ospf6_hello_print(struct ospf6_header *oh)
99 {
100 struct ospf6_hello *hello;
101 char options[16];
102 char drouter[16], bdrouter[16], neighbor[16];
103 char *p;
104
105 ospf6_header_print(oh);
106 assert(oh->type == OSPF6_MESSAGE_TYPE_HELLO);
107
108 hello = (struct ospf6_hello *)((caddr_t)oh
109 + sizeof(struct ospf6_header));
110
111 inet_ntop(AF_INET, &hello->drouter, drouter, sizeof(drouter));
112 inet_ntop(AF_INET, &hello->bdrouter, bdrouter, sizeof(bdrouter));
113 ospf6_options_printbuf(hello->options, options, sizeof(options));
114
115 zlog_debug(" I/F-Id:%ld Priority:%d Option:%s",
116 (unsigned long)ntohl(hello->interface_id), hello->priority,
117 options);
118 zlog_debug(" HelloInterval:%hu DeadInterval:%hu",
119 ntohs(hello->hello_interval), ntohs(hello->dead_interval));
120 zlog_debug(" DR:%s BDR:%s", drouter, bdrouter);
121
122 for (p = (char *)((caddr_t)hello + sizeof(struct ospf6_hello));
123 p + sizeof(uint32_t) <= OSPF6_MESSAGE_END(oh);
124 p += sizeof(uint32_t)) {
125 inet_ntop(AF_INET, (void *)p, neighbor, sizeof(neighbor));
126 zlog_debug(" Neighbor: %s", neighbor);
127 }
128
129 assert(p == OSPF6_MESSAGE_END(oh));
130 }
131
132 void ospf6_dbdesc_print(struct ospf6_header *oh)
133 {
134 struct ospf6_dbdesc *dbdesc;
135 char options[16];
136 char *p;
137
138 ospf6_header_print(oh);
139 assert(oh->type == OSPF6_MESSAGE_TYPE_DBDESC);
140
141 dbdesc = (struct ospf6_dbdesc *)((caddr_t)oh
142 + sizeof(struct ospf6_header));
143
144 ospf6_options_printbuf(dbdesc->options, options, sizeof(options));
145
146 zlog_debug(" MBZ: %#x Option: %s IfMTU: %hu", dbdesc->reserved1,
147 options, ntohs(dbdesc->ifmtu));
148 zlog_debug(" MBZ: %#x Bits: %s%s%s SeqNum: %#lx", dbdesc->reserved2,
149 (CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_IBIT) ? "I" : "-"),
150 (CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_MBIT) ? "M" : "-"),
151 (CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_MSBIT) ? "m" : "s"),
152 (unsigned long)ntohl(dbdesc->seqnum));
153
154 for (p = (char *)((caddr_t)dbdesc + sizeof(struct ospf6_dbdesc));
155 p + sizeof(struct ospf6_lsa_header) <= OSPF6_MESSAGE_END(oh);
156 p += sizeof(struct ospf6_lsa_header))
157 ospf6_lsa_header_print_raw((struct ospf6_lsa_header *)p);
158
159 assert(p == OSPF6_MESSAGE_END(oh));
160 }
161
162 void ospf6_lsreq_print(struct ospf6_header *oh)
163 {
164 char id[16], adv_router[16];
165 char *p;
166
167 ospf6_header_print(oh);
168 assert(oh->type == OSPF6_MESSAGE_TYPE_LSREQ);
169
170 for (p = (char *)((caddr_t)oh + sizeof(struct ospf6_header));
171 p + sizeof(struct ospf6_lsreq_entry) <= OSPF6_MESSAGE_END(oh);
172 p += sizeof(struct ospf6_lsreq_entry)) {
173 struct ospf6_lsreq_entry *e = (struct ospf6_lsreq_entry *)p;
174 inet_ntop(AF_INET, &e->adv_router, adv_router,
175 sizeof(adv_router));
176 inet_ntop(AF_INET, &e->id, id, sizeof(id));
177 zlog_debug(" [%s Id:%s Adv:%s]", ospf6_lstype_name(e->type),
178 id, adv_router);
179 }
180
181 assert(p == OSPF6_MESSAGE_END(oh));
182 }
183
184 void ospf6_lsupdate_print(struct ospf6_header *oh)
185 {
186 struct ospf6_lsupdate *lsupdate;
187 unsigned long num;
188 char *p;
189
190 ospf6_header_print(oh);
191 assert(oh->type == OSPF6_MESSAGE_TYPE_LSUPDATE);
192
193 lsupdate = (struct ospf6_lsupdate *)((caddr_t)oh
194 + sizeof(struct ospf6_header));
195
196 num = ntohl(lsupdate->lsa_number);
197 zlog_debug(" Number of LSA: %ld", num);
198
199 for (p = (char *)((caddr_t)lsupdate + sizeof(struct ospf6_lsupdate));
200 p < OSPF6_MESSAGE_END(oh)
201 && p + OSPF6_LSA_SIZE(p) <= OSPF6_MESSAGE_END(oh);
202 p += OSPF6_LSA_SIZE(p)) {
203 ospf6_lsa_header_print_raw((struct ospf6_lsa_header *)p);
204 }
205
206 assert(p == OSPF6_MESSAGE_END(oh));
207 }
208
209 void ospf6_lsack_print(struct ospf6_header *oh)
210 {
211 char *p;
212
213 ospf6_header_print(oh);
214 assert(oh->type == OSPF6_MESSAGE_TYPE_LSACK);
215
216 for (p = (char *)((caddr_t)oh + sizeof(struct ospf6_header));
217 p + sizeof(struct ospf6_lsa_header) <= OSPF6_MESSAGE_END(oh);
218 p += sizeof(struct ospf6_lsa_header))
219 ospf6_lsa_header_print_raw((struct ospf6_lsa_header *)p);
220
221 assert(p == OSPF6_MESSAGE_END(oh));
222 }
223
224 static void ospf6_hello_recv(struct in6_addr *src, struct in6_addr *dst,
225 struct ospf6_interface *oi,
226 struct ospf6_header *oh)
227 {
228 struct ospf6_hello *hello;
229 struct ospf6_neighbor *on;
230 char *p;
231 int twoway = 0;
232 int neighborchange = 0;
233 int neighbor_ifindex_change = 0;
234 int backupseen = 0;
235
236 hello = (struct ospf6_hello *)((caddr_t)oh
237 + sizeof(struct ospf6_header));
238
239 /* HelloInterval check */
240 if (ntohs(hello->hello_interval) != oi->hello_interval) {
241 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
242 zlog_debug("HelloInterval mismatch");
243 return;
244 }
245
246 /* RouterDeadInterval check */
247 if (ntohs(hello->dead_interval) != oi->dead_interval) {
248 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
249 zlog_debug("RouterDeadInterval mismatch");
250 return;
251 }
252
253 /* E-bit check */
254 if (OSPF6_OPT_ISSET(hello->options, OSPF6_OPT_E)
255 != OSPF6_OPT_ISSET(oi->area->options, OSPF6_OPT_E)) {
256 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
257 zlog_debug("E-bit mismatch");
258 return;
259 }
260
261 /* Find neighbor, create if not exist */
262 on = ospf6_neighbor_lookup(oh->router_id, oi);
263 if (on == NULL) {
264 on = ospf6_neighbor_create(oh->router_id, oi);
265 on->prev_drouter = on->drouter = hello->drouter;
266 on->prev_bdrouter = on->bdrouter = hello->bdrouter;
267 on->priority = hello->priority;
268 }
269
270 /* Always override neighbor's source address */
271 memcpy(&on->linklocal_addr, src, sizeof(struct in6_addr));
272
273 /* Neighbor ifindex check */
274 if (on->ifindex != (ifindex_t)ntohl(hello->interface_id)) {
275 on->ifindex = ntohl(hello->interface_id);
276 neighbor_ifindex_change++;
277 }
278
279 /* TwoWay check */
280 for (p = (char *)((caddr_t)hello + sizeof(struct ospf6_hello));
281 p + sizeof(uint32_t) <= OSPF6_MESSAGE_END(oh);
282 p += sizeof(uint32_t)) {
283 uint32_t *router_id = (uint32_t *)p;
284
285 if (*router_id == oi->area->ospf6->router_id)
286 twoway++;
287 }
288
289 assert(p == OSPF6_MESSAGE_END(oh));
290
291 /* RouterPriority check */
292 if (on->priority != hello->priority) {
293 on->priority = hello->priority;
294 neighborchange++;
295 }
296
297 /* DR check */
298 if (on->drouter != hello->drouter) {
299 on->prev_drouter = on->drouter;
300 on->drouter = hello->drouter;
301 if (on->prev_drouter == on->router_id
302 || on->drouter == on->router_id)
303 neighborchange++;
304 }
305
306 /* BDR check */
307 if (on->bdrouter != hello->bdrouter) {
308 on->prev_bdrouter = on->bdrouter;
309 on->bdrouter = hello->bdrouter;
310 if (on->prev_bdrouter == on->router_id
311 || on->bdrouter == on->router_id)
312 neighborchange++;
313 }
314
315 /* BackupSeen check */
316 if (oi->state == OSPF6_INTERFACE_WAITING) {
317 if (hello->bdrouter == on->router_id)
318 backupseen++;
319 else if (hello->drouter == on->router_id
320 && hello->bdrouter == htonl(0))
321 backupseen++;
322 }
323
324 oi->hello_in++;
325
326 /* Execute neighbor events */
327 thread_execute(master, hello_received, on, 0);
328 if (twoway)
329 thread_execute(master, twoway_received, on, 0);
330 else
331 thread_execute(master, oneway_received, on, 0);
332
333 /* Schedule interface events */
334 if (backupseen)
335 thread_add_event(master, backup_seen, oi, 0, NULL);
336 if (neighborchange)
337 thread_add_event(master, neighbor_change, oi, 0, NULL);
338
339 if (neighbor_ifindex_change && on->state == OSPF6_NEIGHBOR_FULL)
340 OSPF6_ROUTER_LSA_SCHEDULE(oi->area);
341 }
342
343 static void ospf6_dbdesc_recv_master(struct ospf6_header *oh,
344 struct ospf6_neighbor *on)
345 {
346 struct ospf6_dbdesc *dbdesc;
347 char *p;
348
349 dbdesc = (struct ospf6_dbdesc *)((caddr_t)oh
350 + sizeof(struct ospf6_header));
351
352 if (on->state < OSPF6_NEIGHBOR_INIT) {
353 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
354 zlog_debug("Neighbor state less than Init, ignore");
355 return;
356 }
357
358 switch (on->state) {
359 case OSPF6_NEIGHBOR_TWOWAY:
360 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
361 zlog_debug("Neighbor state is 2-Way, ignore");
362 return;
363
364 case OSPF6_NEIGHBOR_INIT:
365 thread_execute(master, twoway_received, on, 0);
366 if (on->state != OSPF6_NEIGHBOR_EXSTART) {
367 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
368 zlog_debug(
369 "Neighbor state is not ExStart, ignore");
370 return;
371 }
372 /* else fall through to ExStart */
373 /* fallthru */
374 case OSPF6_NEIGHBOR_EXSTART:
375 /* if neighbor obeys us as our slave, schedule negotiation_done
376 and process LSA Headers. Otherwise, ignore this message */
377 if (!CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_MSBIT)
378 && !CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_IBIT)
379 && ntohl(dbdesc->seqnum) == on->dbdesc_seqnum) {
380 /* execute NegotiationDone */
381 thread_execute(master, negotiation_done, on, 0);
382
383 /* Record neighbor options */
384 memcpy(on->options, dbdesc->options,
385 sizeof(on->options));
386 } else {
387 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
388 zlog_debug("Negotiation failed");
389 return;
390 }
391 /* fall through to exchange */
392
393 case OSPF6_NEIGHBOR_EXCHANGE:
394 if (!memcmp(dbdesc, &on->dbdesc_last,
395 sizeof(struct ospf6_dbdesc))) {
396 /* Duplicated DatabaseDescription is dropped by master
397 */
398 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
399 zlog_debug(
400 "Duplicated dbdesc discarded by Master, ignore");
401 return;
402 }
403
404 if (CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_MSBIT)) {
405 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
406 zlog_debug("Master/Slave bit mismatch");
407 thread_add_event(master, seqnumber_mismatch, on, 0,
408 NULL);
409 return;
410 }
411
412 if (CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_IBIT)) {
413 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
414 zlog_debug("Initialize bit mismatch");
415 thread_add_event(master, seqnumber_mismatch, on, 0,
416 NULL);
417 return;
418 }
419
420 if (memcmp(on->options, dbdesc->options, sizeof(on->options))) {
421 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
422 zlog_debug("Option field mismatch");
423 thread_add_event(master, seqnumber_mismatch, on, 0,
424 NULL);
425 return;
426 }
427
428 if (ntohl(dbdesc->seqnum) != on->dbdesc_seqnum) {
429 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
430 zlog_debug(
431 "Sequence number mismatch (%#lx expected)",
432 (unsigned long)on->dbdesc_seqnum);
433 thread_add_event(master, seqnumber_mismatch, on, 0,
434 NULL);
435 return;
436 }
437 break;
438
439 case OSPF6_NEIGHBOR_LOADING:
440 case OSPF6_NEIGHBOR_FULL:
441 if (!memcmp(dbdesc, &on->dbdesc_last,
442 sizeof(struct ospf6_dbdesc))) {
443 /* Duplicated DatabaseDescription is dropped by master
444 */
445 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
446 zlog_debug(
447 "Duplicated dbdesc discarded by Master, ignore");
448 return;
449 }
450
451 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
452 zlog_debug("Not duplicate dbdesc in state %s",
453 ospf6_neighbor_state_str[on->state]);
454 thread_add_event(master, seqnumber_mismatch, on, 0, NULL);
455 return;
456
457 default:
458 assert(0);
459 break;
460 }
461
462 /* Process LSA headers */
463 for (p = (char *)((caddr_t)dbdesc + sizeof(struct ospf6_dbdesc));
464 p + sizeof(struct ospf6_lsa_header) <= OSPF6_MESSAGE_END(oh);
465 p += sizeof(struct ospf6_lsa_header)) {
466 struct ospf6_lsa *his, *mine;
467 struct ospf6_lsdb *lsdb = NULL;
468
469 his = ospf6_lsa_create_headeronly((struct ospf6_lsa_header *)p);
470
471 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
472 zlog_debug("%s", his->name);
473
474 switch (OSPF6_LSA_SCOPE(his->header->type)) {
475 case OSPF6_SCOPE_LINKLOCAL:
476 lsdb = on->ospf6_if->lsdb;
477 break;
478 case OSPF6_SCOPE_AREA:
479 lsdb = on->ospf6_if->area->lsdb;
480 break;
481 case OSPF6_SCOPE_AS:
482 lsdb = on->ospf6_if->area->ospf6->lsdb;
483 break;
484 case OSPF6_SCOPE_RESERVED:
485 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
486 zlog_debug("Ignoring LSA of reserved scope");
487 ospf6_lsa_delete(his);
488 continue;
489 break;
490 }
491
492 if (ntohs(his->header->type) == OSPF6_LSTYPE_AS_EXTERNAL
493 && IS_AREA_STUB(on->ospf6_if->area)) {
494 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
495 zlog_debug(
496 "SeqNumMismatch (E-bit mismatch), discard");
497 ospf6_lsa_delete(his);
498 thread_add_event(master, seqnumber_mismatch, on, 0,
499 NULL);
500 return;
501 }
502
503 mine = ospf6_lsdb_lookup(his->header->type, his->header->id,
504 his->header->adv_router, lsdb);
505 if (mine == NULL) {
506 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
507 zlog_debug("Add request (No database copy)");
508 ospf6_lsdb_add(ospf6_lsa_copy(his), on->request_list);
509 } else if (ospf6_lsa_compare(his, mine) < 0) {
510 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
511 zlog_debug("Add request (Received MoreRecent)");
512 ospf6_lsdb_add(ospf6_lsa_copy(his), on->request_list);
513 } else {
514 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
515 zlog_debug("Discard (Existing MoreRecent)");
516 }
517 ospf6_lsa_delete(his);
518 }
519
520 assert(p == OSPF6_MESSAGE_END(oh));
521
522 /* Increment sequence number */
523 on->dbdesc_seqnum++;
524
525 /* schedule send lsreq */
526 if (on->request_list->count)
527 thread_add_event(master, ospf6_lsreq_send, on, 0,
528 &on->thread_send_lsreq);
529
530 THREAD_OFF(on->thread_send_dbdesc);
531
532 /* More bit check */
533 if (!CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_MBIT)
534 && !CHECK_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MBIT))
535 thread_add_event(master, exchange_done, on, 0, NULL);
536 else {
537 on->thread_send_dbdesc = NULL;
538 thread_add_event(master, ospf6_dbdesc_send_newone, on, 0,
539 &on->thread_send_dbdesc);
540 }
541
542 /* save last received dbdesc */
543 memcpy(&on->dbdesc_last, dbdesc, sizeof(struct ospf6_dbdesc));
544 }
545
546 static void ospf6_dbdesc_recv_slave(struct ospf6_header *oh,
547 struct ospf6_neighbor *on)
548 {
549 struct ospf6_dbdesc *dbdesc;
550 char *p;
551
552 dbdesc = (struct ospf6_dbdesc *)((caddr_t)oh
553 + sizeof(struct ospf6_header));
554
555 if (on->state < OSPF6_NEIGHBOR_INIT) {
556 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
557 zlog_debug("Neighbor state less than Init, ignore");
558 return;
559 }
560
561 switch (on->state) {
562 case OSPF6_NEIGHBOR_TWOWAY:
563 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
564 zlog_debug("Neighbor state is 2-Way, ignore");
565 return;
566
567 case OSPF6_NEIGHBOR_INIT:
568 thread_execute(master, twoway_received, on, 0);
569 if (on->state != OSPF6_NEIGHBOR_EXSTART) {
570 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
571 zlog_debug(
572 "Neighbor state is not ExStart, ignore");
573 return;
574 }
575 /* else fall through to ExStart */
576 /* fallthru */
577 case OSPF6_NEIGHBOR_EXSTART:
578 /* If the neighbor is Master, act as Slave. Schedule
579 negotiation_done
580 and process LSA Headers. Otherwise, ignore this message */
581 if (CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_IBIT)
582 && CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_MBIT)
583 && CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_MSBIT)
584 && ntohs(oh->length)
585 == sizeof(struct ospf6_header)
586 + sizeof(struct ospf6_dbdesc)) {
587 /* set the master/slave bit to slave */
588 UNSET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MSBIT);
589
590 /* set the DD sequence number to one specified by master
591 */
592 on->dbdesc_seqnum = ntohl(dbdesc->seqnum);
593
594 /* schedule NegotiationDone */
595 thread_execute(master, negotiation_done, on, 0);
596
597 /* Record neighbor options */
598 memcpy(on->options, dbdesc->options,
599 sizeof(on->options));
600 } else {
601 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
602 zlog_debug("Negotiation failed");
603 return;
604 }
605 break;
606
607 case OSPF6_NEIGHBOR_EXCHANGE:
608 if (!memcmp(dbdesc, &on->dbdesc_last,
609 sizeof(struct ospf6_dbdesc))) {
610 /* Duplicated DatabaseDescription causes slave to
611 * retransmit */
612 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
613 zlog_debug(
614 "Duplicated dbdesc causes retransmit");
615 THREAD_OFF(on->thread_send_dbdesc);
616 on->thread_send_dbdesc = NULL;
617 thread_add_event(master, ospf6_dbdesc_send, on, 0,
618 &on->thread_send_dbdesc);
619 return;
620 }
621
622 if (!CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_MSBIT)) {
623 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
624 zlog_debug("Master/Slave bit mismatch");
625 thread_add_event(master, seqnumber_mismatch, on, 0,
626 NULL);
627 return;
628 }
629
630 if (CHECK_FLAG(dbdesc->bits, OSPF6_DBDESC_IBIT)) {
631 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
632 zlog_debug("Initialize bit mismatch");
633 thread_add_event(master, seqnumber_mismatch, on, 0,
634 NULL);
635 return;
636 }
637
638 if (memcmp(on->options, dbdesc->options, sizeof(on->options))) {
639 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
640 zlog_debug("Option field mismatch");
641 thread_add_event(master, seqnumber_mismatch, on, 0,
642 NULL);
643 return;
644 }
645
646 if (ntohl(dbdesc->seqnum) != on->dbdesc_seqnum + 1) {
647 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
648 zlog_debug(
649 "Sequence number mismatch (%#lx expected)",
650 (unsigned long)on->dbdesc_seqnum + 1);
651 thread_add_event(master, seqnumber_mismatch, on, 0,
652 NULL);
653 return;
654 }
655 break;
656
657 case OSPF6_NEIGHBOR_LOADING:
658 case OSPF6_NEIGHBOR_FULL:
659 if (!memcmp(dbdesc, &on->dbdesc_last,
660 sizeof(struct ospf6_dbdesc))) {
661 /* Duplicated DatabaseDescription causes slave to
662 * retransmit */
663 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
664 zlog_debug(
665 "Duplicated dbdesc causes retransmit");
666 THREAD_OFF(on->thread_send_dbdesc);
667 thread_add_event(master, ospf6_dbdesc_send, on, 0,
668 &on->thread_send_dbdesc);
669 return;
670 }
671
672 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
673 zlog_debug("Not duplicate dbdesc in state %s",
674 ospf6_neighbor_state_str[on->state]);
675 thread_add_event(master, seqnumber_mismatch, on, 0, NULL);
676 return;
677
678 default:
679 assert(0);
680 break;
681 }
682
683 /* Process LSA headers */
684 for (p = (char *)((caddr_t)dbdesc + sizeof(struct ospf6_dbdesc));
685 p + sizeof(struct ospf6_lsa_header) <= OSPF6_MESSAGE_END(oh);
686 p += sizeof(struct ospf6_lsa_header)) {
687 struct ospf6_lsa *his, *mine;
688 struct ospf6_lsdb *lsdb = NULL;
689
690 his = ospf6_lsa_create_headeronly((struct ospf6_lsa_header *)p);
691
692 switch (OSPF6_LSA_SCOPE(his->header->type)) {
693 case OSPF6_SCOPE_LINKLOCAL:
694 lsdb = on->ospf6_if->lsdb;
695 break;
696 case OSPF6_SCOPE_AREA:
697 lsdb = on->ospf6_if->area->lsdb;
698 break;
699 case OSPF6_SCOPE_AS:
700 lsdb = on->ospf6_if->area->ospf6->lsdb;
701 break;
702 case OSPF6_SCOPE_RESERVED:
703 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
704 zlog_debug("Ignoring LSA of reserved scope");
705 ospf6_lsa_delete(his);
706 continue;
707 break;
708 }
709
710 if (OSPF6_LSA_SCOPE(his->header->type) == OSPF6_SCOPE_AS
711 && IS_AREA_STUB(on->ospf6_if->area)) {
712 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
713 zlog_debug("E-bit mismatch with LSA Headers");
714 ospf6_lsa_delete(his);
715 thread_add_event(master, seqnumber_mismatch, on, 0,
716 NULL);
717 return;
718 }
719
720 mine = ospf6_lsdb_lookup(his->header->type, his->header->id,
721 his->header->adv_router, lsdb);
722 if (mine == NULL || ospf6_lsa_compare(his, mine) < 0) {
723 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
724 zlog_debug("Add request-list: %s", his->name);
725 ospf6_lsdb_add(ospf6_lsa_copy(his), on->request_list);
726 }
727 ospf6_lsa_delete(his);
728 }
729
730 assert(p == OSPF6_MESSAGE_END(oh));
731
732 /* Set sequence number to Master's */
733 on->dbdesc_seqnum = ntohl(dbdesc->seqnum);
734
735 /* schedule send lsreq */
736 if (on->request_list->count)
737 thread_add_event(master, ospf6_lsreq_send, on, 0,
738 &on->thread_send_lsreq);
739
740 THREAD_OFF(on->thread_send_dbdesc);
741 thread_add_event(master, ospf6_dbdesc_send_newone, on, 0,
742 &on->thread_send_dbdesc);
743
744 /* save last received dbdesc */
745 memcpy(&on->dbdesc_last, dbdesc, sizeof(struct ospf6_dbdesc));
746 }
747
748 static void ospf6_dbdesc_recv(struct in6_addr *src, struct in6_addr *dst,
749 struct ospf6_interface *oi,
750 struct ospf6_header *oh)
751 {
752 struct ospf6_neighbor *on;
753 struct ospf6_dbdesc *dbdesc;
754
755 on = ospf6_neighbor_lookup(oh->router_id, oi);
756 if (on == NULL) {
757 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
758 zlog_debug("Neighbor not found, ignore");
759 return;
760 }
761
762 dbdesc = (struct ospf6_dbdesc *)((caddr_t)oh
763 + sizeof(struct ospf6_header));
764
765 /* Interface MTU check */
766 if (!oi->mtu_ignore && ntohs(dbdesc->ifmtu) != oi->ifmtu) {
767 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
768 zlog_debug("I/F MTU mismatch");
769 return;
770 }
771
772 if (dbdesc->reserved1 || dbdesc->reserved2) {
773 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
774 zlog_debug(
775 "Non-0 reserved field in %s's DbDesc, correct",
776 on->name);
777 dbdesc->reserved1 = 0;
778 dbdesc->reserved2 = 0;
779 }
780
781 oi->db_desc_in++;
782
783 if (ntohl(oh->router_id) < ntohl(ospf6->router_id))
784 ospf6_dbdesc_recv_master(oh, on);
785 else if (ntohl(ospf6->router_id) < ntohl(oh->router_id))
786 ospf6_dbdesc_recv_slave(oh, on);
787 else {
788 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
789 zlog_debug("Can't decide which is master, ignore");
790 }
791 }
792
793 static void ospf6_lsreq_recv(struct in6_addr *src, struct in6_addr *dst,
794 struct ospf6_interface *oi,
795 struct ospf6_header *oh)
796 {
797 struct ospf6_neighbor *on;
798 char *p;
799 struct ospf6_lsreq_entry *e;
800 struct ospf6_lsdb *lsdb = NULL;
801 struct ospf6_lsa *lsa;
802
803 on = ospf6_neighbor_lookup(oh->router_id, oi);
804 if (on == NULL) {
805 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
806 zlog_debug("Neighbor not found, ignore");
807 return;
808 }
809
810 if (on->state != OSPF6_NEIGHBOR_EXCHANGE
811 && on->state != OSPF6_NEIGHBOR_LOADING
812 && on->state != OSPF6_NEIGHBOR_FULL) {
813 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
814 zlog_debug("Neighbor state less than Exchange, ignore");
815 return;
816 }
817
818 oi->ls_req_in++;
819
820 /* Process each request */
821 for (p = (char *)((caddr_t)oh + sizeof(struct ospf6_header));
822 p + sizeof(struct ospf6_lsreq_entry) <= OSPF6_MESSAGE_END(oh);
823 p += sizeof(struct ospf6_lsreq_entry)) {
824 e = (struct ospf6_lsreq_entry *)p;
825
826 switch (OSPF6_LSA_SCOPE(e->type)) {
827 case OSPF6_SCOPE_LINKLOCAL:
828 lsdb = on->ospf6_if->lsdb;
829 break;
830 case OSPF6_SCOPE_AREA:
831 lsdb = on->ospf6_if->area->lsdb;
832 break;
833 case OSPF6_SCOPE_AS:
834 lsdb = on->ospf6_if->area->ospf6->lsdb;
835 break;
836 default:
837 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
838 zlog_debug("Ignoring LSA of reserved scope");
839 continue;
840 break;
841 }
842
843 /* Find database copy */
844 lsa = ospf6_lsdb_lookup(e->type, e->id, e->adv_router, lsdb);
845 if (lsa == NULL) {
846 char id[16], adv_router[16];
847 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV)) {
848 inet_ntop(AF_INET, &e->id, id, sizeof(id));
849 inet_ntop(AF_INET, &e->adv_router, adv_router,
850 sizeof(adv_router));
851 zlog_debug(
852 "Can't find requested [%s Id:%s Adv:%s]",
853 ospf6_lstype_name(e->type), id,
854 adv_router);
855 }
856 thread_add_event(master, bad_lsreq, on, 0, NULL);
857 return;
858 }
859
860 ospf6_lsdb_add(ospf6_lsa_copy(lsa), on->lsupdate_list);
861 }
862
863 assert(p == OSPF6_MESSAGE_END(oh));
864
865 /* schedule send lsupdate */
866 THREAD_OFF(on->thread_send_lsupdate);
867 thread_add_event(master, ospf6_lsupdate_send_neighbor, on, 0,
868 &on->thread_send_lsupdate);
869 }
870
871 /* Verify, that the specified memory area contains exactly N valid IPv6
872 prefixes as specified by RFC5340, A.4.1. */
873 static unsigned ospf6_prefixes_examin(
874 struct ospf6_prefix *current, /* start of buffer */
875 unsigned length,
876 const uint32_t req_num_pfxs /* always compared with the actual number
877 of prefixes */
878 )
879 {
880 uint8_t requested_pfx_bytes;
881 uint32_t real_num_pfxs = 0;
882
883 while (length) {
884 if (length < OSPF6_PREFIX_MIN_SIZE) {
885 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN,
886 RECV))
887 zlog_debug("%s: undersized IPv6 prefix header",
888 __func__);
889 return MSG_NG;
890 }
891 /* safe to look deeper */
892 if (current->prefix_length > IPV6_MAX_BITLEN) {
893 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN,
894 RECV))
895 zlog_debug("%s: invalid PrefixLength (%u bits)",
896 __func__, current->prefix_length);
897 return MSG_NG;
898 }
899 /* covers both fixed- and variable-sized fields */
900 requested_pfx_bytes =
901 OSPF6_PREFIX_MIN_SIZE
902 + OSPF6_PREFIX_SPACE(current->prefix_length);
903 if (requested_pfx_bytes > length) {
904 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN,
905 RECV))
906 zlog_debug("%s: undersized IPv6 prefix",
907 __func__);
908 return MSG_NG;
909 }
910 /* next prefix */
911 length -= requested_pfx_bytes;
912 current = (struct ospf6_prefix *)((caddr_t)current
913 + requested_pfx_bytes);
914 real_num_pfxs++;
915 }
916 if (real_num_pfxs != req_num_pfxs) {
917 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
918 zlog_debug(
919 "%s: IPv6 prefix number mismatch (%u required, %u real)",
920 __func__, req_num_pfxs, real_num_pfxs);
921 return MSG_NG;
922 }
923 return MSG_OK;
924 }
925
926 /* Verify an LSA to have a valid length and dispatch further (where
927 appropriate) to check if the contents, including nested IPv6 prefixes,
928 is properly sized/aligned within the LSA. Note that this function gets
929 LSA type in network byte order, uses in host byte order and passes to
930 ospf6_lstype_name() in network byte order again. */
931 static unsigned ospf6_lsa_examin(struct ospf6_lsa_header *lsah,
932 const uint16_t lsalen,
933 const uint8_t headeronly)
934 {
935 struct ospf6_intra_prefix_lsa *intra_prefix_lsa;
936 struct ospf6_as_external_lsa *as_external_lsa;
937 struct ospf6_link_lsa *link_lsa;
938 unsigned exp_length;
939 uint8_t ltindex;
940 uint16_t lsatype;
941
942 /* In case an additional minimum length constraint is defined for
943 current
944 LSA type, make sure that this constraint is met. */
945 lsatype = ntohs(lsah->type);
946 ltindex = lsatype & OSPF6_LSTYPE_FCODE_MASK;
947 if (ltindex < OSPF6_LSTYPE_SIZE && ospf6_lsa_minlen[ltindex]
948 && lsalen < ospf6_lsa_minlen[ltindex] + OSPF6_LSA_HEADER_SIZE) {
949 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
950 zlog_debug("%s: undersized (%u B) LSA", __func__,
951 lsalen);
952 return MSG_NG;
953 }
954 switch (lsatype) {
955 case OSPF6_LSTYPE_ROUTER:
956 /* RFC5340 A.4.3, LSA header + OSPF6_ROUTER_LSA_MIN_SIZE bytes
957 followed
958 by N>=0 interface descriptions. */
959 if ((lsalen - OSPF6_LSA_HEADER_SIZE - OSPF6_ROUTER_LSA_MIN_SIZE)
960 % OSPF6_ROUTER_LSDESC_FIX_SIZE) {
961 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN,
962 RECV))
963 zlog_debug(
964 "%s: interface description alignment error",
965 __func__);
966 return MSG_NG;
967 }
968 break;
969 case OSPF6_LSTYPE_NETWORK:
970 /* RFC5340 A.4.4, LSA header + OSPF6_NETWORK_LSA_MIN_SIZE bytes
971 followed by N>=0 attached router descriptions. */
972 if ((lsalen - OSPF6_LSA_HEADER_SIZE
973 - OSPF6_NETWORK_LSA_MIN_SIZE)
974 % OSPF6_NETWORK_LSDESC_FIX_SIZE) {
975 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN,
976 RECV))
977 zlog_debug(
978 "%s: router description alignment error",
979 __func__);
980 return MSG_NG;
981 }
982 break;
983 case OSPF6_LSTYPE_INTER_PREFIX:
984 /* RFC5340 A.4.5, LSA header + OSPF6_INTER_PREFIX_LSA_MIN_SIZE
985 bytes
986 followed by 3-4 fields of a single IPv6 prefix. */
987 if (headeronly)
988 break;
989 return ospf6_prefixes_examin(
990 (struct ospf6_prefix
991 *)((caddr_t)lsah + OSPF6_LSA_HEADER_SIZE
992 + OSPF6_INTER_PREFIX_LSA_MIN_SIZE),
993 lsalen - OSPF6_LSA_HEADER_SIZE
994 - OSPF6_INTER_PREFIX_LSA_MIN_SIZE,
995 1);
996 case OSPF6_LSTYPE_INTER_ROUTER:
997 /* RFC5340 A.4.6, fixed-size LSA. */
998 if (lsalen
999 > OSPF6_LSA_HEADER_SIZE + OSPF6_INTER_ROUTER_LSA_FIX_SIZE) {
1000 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN,
1001 RECV))
1002 zlog_debug("%s: oversized (%u B) LSA", __func__,
1003 lsalen);
1004 return MSG_NG;
1005 }
1006 break;
1007 case OSPF6_LSTYPE_AS_EXTERNAL: /* RFC5340 A.4.7, same as A.4.8. */
1008 case OSPF6_LSTYPE_TYPE_7:
1009 /* RFC5340 A.4.8, LSA header + OSPF6_AS_EXTERNAL_LSA_MIN_SIZE
1010 bytes
1011 followed by 3-4 fields of IPv6 prefix and 3 conditional LSA
1012 fields:
1013 16 bytes of forwarding address, 4 bytes of external route
1014 tag,
1015 4 bytes of referenced link state ID. */
1016 if (headeronly)
1017 break;
1018 as_external_lsa =
1019 (struct ospf6_as_external_lsa
1020 *)((caddr_t)lsah + OSPF6_LSA_HEADER_SIZE);
1021 exp_length =
1022 OSPF6_LSA_HEADER_SIZE + OSPF6_AS_EXTERNAL_LSA_MIN_SIZE;
1023 /* To find out if the last optional field (Referenced Link State
1024 ID) is
1025 assumed in this LSA, we need to access fixed fields of the
1026 IPv6
1027 prefix before ospf6_prefix_examin() confirms its sizing. */
1028 if (exp_length + OSPF6_PREFIX_MIN_SIZE > lsalen) {
1029 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN,
1030 RECV))
1031 zlog_debug("%s: undersized (%u B) LSA header",
1032 __func__, lsalen);
1033 return MSG_NG;
1034 }
1035 /* forwarding address */
1036 if (CHECK_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_F))
1037 exp_length += 16;
1038 /* external route tag */
1039 if (CHECK_FLAG(as_external_lsa->bits_metric, OSPF6_ASBR_BIT_T))
1040 exp_length += 4;
1041 /* referenced link state ID */
1042 if (as_external_lsa->prefix.u._prefix_referenced_lstype)
1043 exp_length += 4;
1044 /* All the fixed-size fields (mandatory and optional) must fit.
1045 I.e.,
1046 this check does not include any IPv6 prefix fields. */
1047 if (exp_length > lsalen) {
1048 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN,
1049 RECV))
1050 zlog_debug("%s: undersized (%u B) LSA header",
1051 __func__, lsalen);
1052 return MSG_NG;
1053 }
1054 /* The last call completely covers the remainder (IPv6 prefix).
1055 */
1056 return ospf6_prefixes_examin(
1057 (struct ospf6_prefix
1058 *)((caddr_t)as_external_lsa
1059 + OSPF6_AS_EXTERNAL_LSA_MIN_SIZE),
1060 lsalen - exp_length, 1);
1061 case OSPF6_LSTYPE_LINK:
1062 /* RFC5340 A.4.9, LSA header + OSPF6_LINK_LSA_MIN_SIZE bytes
1063 followed
1064 by N>=0 IPv6 prefix blocks (with N declared beforehand). */
1065 if (headeronly)
1066 break;
1067 link_lsa = (struct ospf6_link_lsa *)((caddr_t)lsah
1068 + OSPF6_LSA_HEADER_SIZE);
1069 return ospf6_prefixes_examin(
1070 (struct ospf6_prefix *)((caddr_t)link_lsa
1071 + OSPF6_LINK_LSA_MIN_SIZE),
1072 lsalen - OSPF6_LSA_HEADER_SIZE
1073 - OSPF6_LINK_LSA_MIN_SIZE,
1074 ntohl(link_lsa->prefix_num) /* 32 bits */
1075 );
1076 case OSPF6_LSTYPE_INTRA_PREFIX:
1077 /* RFC5340 A.4.10, LSA header + OSPF6_INTRA_PREFIX_LSA_MIN_SIZE
1078 bytes
1079 followed by N>=0 IPv6 prefixes (with N declared beforehand).
1080 */
1081 if (headeronly)
1082 break;
1083 intra_prefix_lsa =
1084 (struct ospf6_intra_prefix_lsa
1085 *)((caddr_t)lsah + OSPF6_LSA_HEADER_SIZE);
1086 return ospf6_prefixes_examin(
1087 (struct ospf6_prefix
1088 *)((caddr_t)intra_prefix_lsa
1089 + OSPF6_INTRA_PREFIX_LSA_MIN_SIZE),
1090 lsalen - OSPF6_LSA_HEADER_SIZE
1091 - OSPF6_INTRA_PREFIX_LSA_MIN_SIZE,
1092 ntohs(intra_prefix_lsa->prefix_num) /* 16 bits */
1093 );
1094 }
1095 /* No additional validation is possible for unknown LSA types, which are
1096 themselves valid in OPSFv3, hence the default decision is to accept.
1097 */
1098 return MSG_OK;
1099 }
1100
1101 /* Verify if the provided input buffer is a valid sequence of LSAs. This
1102 includes verification of LSA blocks length/alignment and dispatching
1103 of deeper-level checks. */
1104 static unsigned
1105 ospf6_lsaseq_examin(struct ospf6_lsa_header *lsah, /* start of buffered data */
1106 size_t length, const uint8_t headeronly,
1107 /* When declared_num_lsas is not 0, compare it to the real
1108 number of LSAs
1109 and treat the difference as an error. */
1110 const uint32_t declared_num_lsas)
1111 {
1112 uint32_t counted_lsas = 0;
1113
1114 while (length) {
1115 uint16_t lsalen;
1116 if (length < OSPF6_LSA_HEADER_SIZE) {
1117 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN,
1118 RECV))
1119 zlog_debug(
1120 "%s: undersized (%zu B) trailing (#%u) LSA header",
1121 __func__, length, counted_lsas);
1122 return MSG_NG;
1123 }
1124 /* save on ntohs() calls here and in the LSA validator */
1125 lsalen = OSPF6_LSA_SIZE(lsah);
1126 if (lsalen < OSPF6_LSA_HEADER_SIZE) {
1127 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN,
1128 RECV))
1129 zlog_debug(
1130 "%s: malformed LSA header #%u, declared length is %u B",
1131 __func__, counted_lsas, lsalen);
1132 return MSG_NG;
1133 }
1134 if (headeronly) {
1135 /* less checks here and in ospf6_lsa_examin() */
1136 if (MSG_OK != ospf6_lsa_examin(lsah, lsalen, 1)) {
1137 if (IS_OSPF6_DEBUG_MESSAGE(
1138 OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
1139 zlog_debug(
1140 "%s: anomaly in header-only %s LSA #%u",
1141 __func__,
1142 ospf6_lstype_name(lsah->type),
1143 counted_lsas);
1144 return MSG_NG;
1145 }
1146 lsah = (struct ospf6_lsa_header
1147 *)((caddr_t)lsah
1148 + OSPF6_LSA_HEADER_SIZE);
1149 length -= OSPF6_LSA_HEADER_SIZE;
1150 } else {
1151 /* make sure the input buffer is deep enough before
1152 * further checks */
1153 if (lsalen > length) {
1154 if (IS_OSPF6_DEBUG_MESSAGE(
1155 OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
1156 zlog_debug(
1157 "%s: anomaly in %s LSA #%u: declared length is %u B, buffered length is %zu B",
1158 __func__,
1159 ospf6_lstype_name(lsah->type),
1160 counted_lsas, lsalen, length);
1161 return MSG_NG;
1162 }
1163 if (MSG_OK != ospf6_lsa_examin(lsah, lsalen, 0)) {
1164 if (IS_OSPF6_DEBUG_MESSAGE(
1165 OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
1166 zlog_debug(
1167 "%s: anomaly in %s LSA #%u",
1168 __func__,
1169 ospf6_lstype_name(lsah->type),
1170 counted_lsas);
1171 return MSG_NG;
1172 }
1173 lsah = (struct ospf6_lsa_header *)((caddr_t)lsah
1174 + lsalen);
1175 length -= lsalen;
1176 }
1177 counted_lsas++;
1178 }
1179
1180 if (declared_num_lsas && counted_lsas != declared_num_lsas) {
1181 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
1182 zlog_debug(
1183 "%s: #LSAs declared (%u) does not match actual (%u)",
1184 __func__, declared_num_lsas, counted_lsas);
1185 return MSG_NG;
1186 }
1187 return MSG_OK;
1188 }
1189
1190 /* Verify a complete OSPF packet for proper sizing/alignment. */
1191 static unsigned ospf6_packet_examin(struct ospf6_header *oh,
1192 const unsigned bytesonwire)
1193 {
1194 struct ospf6_lsupdate *lsupd;
1195 unsigned test;
1196
1197 /* length, 1st approximation */
1198 if (bytesonwire < OSPF6_HEADER_SIZE) {
1199 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
1200 zlog_debug("%s: undersized (%u B) packet", __func__,
1201 bytesonwire);
1202 return MSG_NG;
1203 }
1204 /* Now it is safe to access header fields. */
1205 if (bytesonwire != ntohs(oh->length)) {
1206 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
1207 zlog_debug(
1208 "%s: %s packet length error (%u real, %u declared)",
1209 __func__, lookup_msg(ospf6_message_type_str,
1210 oh->type, NULL),
1211 bytesonwire, ntohs(oh->length));
1212 return MSG_NG;
1213 }
1214 /* version check */
1215 if (oh->version != OSPFV3_VERSION) {
1216 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
1217 zlog_debug("%s: invalid (%u) protocol version",
1218 __func__, oh->version);
1219 return MSG_NG;
1220 }
1221 /* length, 2nd approximation */
1222 if (oh->type < OSPF6_MESSAGE_TYPE_ALL && ospf6_packet_minlen[oh->type]
1223 && bytesonwire
1224 < OSPF6_HEADER_SIZE + ospf6_packet_minlen[oh->type]) {
1225 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
1226 zlog_debug("%s: undersized (%u B) %s packet", __func__,
1227 bytesonwire,
1228 lookup_msg(ospf6_message_type_str, oh->type,
1229 NULL));
1230 return MSG_NG;
1231 }
1232 /* type-specific deeper validation */
1233 switch (oh->type) {
1234 case OSPF6_MESSAGE_TYPE_HELLO:
1235 /* RFC5340 A.3.2, packet header + OSPF6_HELLO_MIN_SIZE bytes
1236 followed
1237 by N>=0 router-IDs. */
1238 if (0
1239 == (bytesonwire - OSPF6_HEADER_SIZE - OSPF6_HELLO_MIN_SIZE)
1240 % 4)
1241 return MSG_OK;
1242 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
1243 zlog_debug("%s: alignment error in %s packet", __func__,
1244 lookup_msg(ospf6_message_type_str, oh->type,
1245 NULL));
1246 return MSG_NG;
1247 case OSPF6_MESSAGE_TYPE_DBDESC:
1248 /* RFC5340 A.3.3, packet header + OSPF6_DB_DESC_MIN_SIZE bytes
1249 followed
1250 by N>=0 header-only LSAs. */
1251 test = ospf6_lsaseq_examin(
1252 (struct ospf6_lsa_header *)((caddr_t)oh
1253 + OSPF6_HEADER_SIZE
1254 + OSPF6_DB_DESC_MIN_SIZE),
1255 bytesonwire - OSPF6_HEADER_SIZE
1256 - OSPF6_DB_DESC_MIN_SIZE,
1257 1, 0);
1258 break;
1259 case OSPF6_MESSAGE_TYPE_LSREQ:
1260 /* RFC5340 A.3.4, packet header + N>=0 LS description blocks. */
1261 if (0
1262 == (bytesonwire - OSPF6_HEADER_SIZE - OSPF6_LS_REQ_MIN_SIZE)
1263 % OSPF6_LSREQ_LSDESC_FIX_SIZE)
1264 return MSG_OK;
1265 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
1266 zlog_debug("%s: alignment error in %s packet", __func__,
1267 lookup_msg(ospf6_message_type_str, oh->type,
1268 NULL));
1269 return MSG_NG;
1270 case OSPF6_MESSAGE_TYPE_LSUPDATE:
1271 /* RFC5340 A.3.5, packet header + OSPF6_LS_UPD_MIN_SIZE bytes
1272 followed
1273 by N>=0 full LSAs (with N declared beforehand). */
1274 lsupd = (struct ospf6_lsupdate *)((caddr_t)oh
1275 + OSPF6_HEADER_SIZE);
1276 test = ospf6_lsaseq_examin(
1277 (struct ospf6_lsa_header *)((caddr_t)lsupd
1278 + OSPF6_LS_UPD_MIN_SIZE),
1279 bytesonwire - OSPF6_HEADER_SIZE - OSPF6_LS_UPD_MIN_SIZE,
1280 0, ntohl(lsupd->lsa_number) /* 32 bits */
1281 );
1282 break;
1283 case OSPF6_MESSAGE_TYPE_LSACK:
1284 /* RFC5340 A.3.6, packet header + N>=0 header-only LSAs. */
1285 test = ospf6_lsaseq_examin(
1286 (struct ospf6_lsa_header *)((caddr_t)oh
1287 + OSPF6_HEADER_SIZE
1288 + OSPF6_LS_ACK_MIN_SIZE),
1289 bytesonwire - OSPF6_HEADER_SIZE - OSPF6_LS_ACK_MIN_SIZE,
1290 1, 0);
1291 break;
1292 default:
1293 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
1294 zlog_debug("%s: invalid (%u) message type", __func__,
1295 oh->type);
1296 return MSG_NG;
1297 }
1298 if (test != MSG_OK
1299 && IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
1300 zlog_debug("%s: anomaly in %s packet", __func__,
1301 lookup_msg(ospf6_message_type_str, oh->type, NULL));
1302 return test;
1303 }
1304
1305 /* Verify particular fields of otherwise correct received OSPF packet to
1306 meet the requirements of RFC. */
1307 static int ospf6_rxpacket_examin(struct ospf6_interface *oi,
1308 struct ospf6_header *oh,
1309 const unsigned bytesonwire)
1310 {
1311 char buf[2][INET_ADDRSTRLEN];
1312
1313 if (MSG_OK != ospf6_packet_examin(oh, bytesonwire))
1314 return MSG_NG;
1315
1316 /* Area-ID check */
1317 if (oh->area_id != oi->area->area_id) {
1318 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV)) {
1319 if (oh->area_id == OSPF_AREA_BACKBONE)
1320 zlog_debug(
1321 "%s: Message may be via Virtual Link: not supported",
1322 __func__);
1323 else
1324 zlog_debug(
1325 "%s: Area-ID mismatch (my %s, rcvd %s)",
1326 __func__,
1327 inet_ntop(AF_INET, &oi->area->area_id,
1328 buf[0], INET_ADDRSTRLEN),
1329 inet_ntop(AF_INET, &oh->area_id, buf[1],
1330 INET_ADDRSTRLEN));
1331 }
1332 return MSG_NG;
1333 }
1334
1335 /* Instance-ID check */
1336 if (oh->instance_id != oi->instance_id) {
1337 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
1338 zlog_debug("%s: Instance-ID mismatch (my %u, rcvd %u)",
1339 __func__, oi->instance_id, oh->instance_id);
1340 return MSG_NG;
1341 }
1342
1343 /* Router-ID check */
1344 if (oh->router_id == oi->area->ospf6->router_id) {
1345 zlog_warn("%s: Duplicate Router-ID (%s)", __func__,
1346 inet_ntop(AF_INET, &oh->router_id, buf[0],
1347 INET_ADDRSTRLEN));
1348 return MSG_NG;
1349 }
1350 return MSG_OK;
1351 }
1352
1353 static void ospf6_lsupdate_recv(struct in6_addr *src, struct in6_addr *dst,
1354 struct ospf6_interface *oi,
1355 struct ospf6_header *oh)
1356 {
1357 struct ospf6_neighbor *on;
1358 struct ospf6_lsupdate *lsupdate;
1359 char *p;
1360
1361 on = ospf6_neighbor_lookup(oh->router_id, oi);
1362 if (on == NULL) {
1363 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
1364 zlog_debug("Neighbor not found, ignore");
1365 return;
1366 }
1367
1368 if (on->state != OSPF6_NEIGHBOR_EXCHANGE
1369 && on->state != OSPF6_NEIGHBOR_LOADING
1370 && on->state != OSPF6_NEIGHBOR_FULL) {
1371 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
1372 zlog_debug("Neighbor state less than Exchange, ignore");
1373 return;
1374 }
1375
1376 lsupdate = (struct ospf6_lsupdate *)((caddr_t)oh
1377 + sizeof(struct ospf6_header));
1378
1379 oi->ls_upd_in++;
1380
1381 /* Process LSAs */
1382 for (p = (char *)((caddr_t)lsupdate + sizeof(struct ospf6_lsupdate));
1383 p < OSPF6_MESSAGE_END(oh)
1384 && p + OSPF6_LSA_SIZE(p) <= OSPF6_MESSAGE_END(oh);
1385 p += OSPF6_LSA_SIZE(p)) {
1386 ospf6_receive_lsa(on, (struct ospf6_lsa_header *)p);
1387 }
1388
1389 assert(p == OSPF6_MESSAGE_END(oh));
1390 }
1391
1392 static void ospf6_lsack_recv(struct in6_addr *src, struct in6_addr *dst,
1393 struct ospf6_interface *oi,
1394 struct ospf6_header *oh)
1395 {
1396 struct ospf6_neighbor *on;
1397 char *p;
1398 struct ospf6_lsa *his, *mine;
1399 struct ospf6_lsdb *lsdb = NULL;
1400
1401 assert(oh->type == OSPF6_MESSAGE_TYPE_LSACK);
1402
1403 on = ospf6_neighbor_lookup(oh->router_id, oi);
1404 if (on == NULL) {
1405 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
1406 zlog_debug("Neighbor not found, ignore");
1407 return;
1408 }
1409
1410 if (on->state != OSPF6_NEIGHBOR_EXCHANGE
1411 && on->state != OSPF6_NEIGHBOR_LOADING
1412 && on->state != OSPF6_NEIGHBOR_FULL) {
1413 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
1414 zlog_debug("Neighbor state less than Exchange, ignore");
1415 return;
1416 }
1417
1418 oi->ls_ack_in++;
1419
1420 for (p = (char *)((caddr_t)oh + sizeof(struct ospf6_header));
1421 p + sizeof(struct ospf6_lsa_header) <= OSPF6_MESSAGE_END(oh);
1422 p += sizeof(struct ospf6_lsa_header)) {
1423 his = ospf6_lsa_create_headeronly((struct ospf6_lsa_header *)p);
1424
1425 switch (OSPF6_LSA_SCOPE(his->header->type)) {
1426 case OSPF6_SCOPE_LINKLOCAL:
1427 lsdb = on->ospf6_if->lsdb;
1428 break;
1429 case OSPF6_SCOPE_AREA:
1430 lsdb = on->ospf6_if->area->lsdb;
1431 break;
1432 case OSPF6_SCOPE_AS:
1433 lsdb = on->ospf6_if->area->ospf6->lsdb;
1434 break;
1435 case OSPF6_SCOPE_RESERVED:
1436 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
1437 zlog_debug("Ignoring LSA of reserved scope");
1438 ospf6_lsa_delete(his);
1439 continue;
1440 break;
1441 }
1442
1443 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
1444 zlog_debug("%s acknowledged by %s", his->name,
1445 on->name);
1446
1447 /* Find database copy */
1448 mine = ospf6_lsdb_lookup(his->header->type, his->header->id,
1449 his->header->adv_router, lsdb);
1450 if (mine == NULL) {
1451 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
1452 zlog_debug("No database copy");
1453 ospf6_lsa_delete(his);
1454 continue;
1455 }
1456
1457 /* Check if the LSA is on his retrans-list */
1458 mine = ospf6_lsdb_lookup(his->header->type, his->header->id,
1459 his->header->adv_router,
1460 on->retrans_list);
1461 if (mine == NULL) {
1462 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
1463 zlog_debug("Not on %s's retrans-list",
1464 on->name);
1465 ospf6_lsa_delete(his);
1466 continue;
1467 }
1468
1469 if (ospf6_lsa_compare(his, mine) != 0) {
1470 /* Log this questionable acknowledgement,
1471 and examine the next one. */
1472 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
1473 zlog_debug("Questionable acknowledgement");
1474 ospf6_lsa_delete(his);
1475 continue;
1476 }
1477
1478 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV))
1479 zlog_debug(
1480 "Acknowledged, remove from %s's retrans-list",
1481 on->name);
1482
1483 ospf6_decrement_retrans_count(mine);
1484 if (OSPF6_LSA_IS_MAXAGE(mine))
1485 ospf6_maxage_remove(on->ospf6_if->area->ospf6);
1486 ospf6_lsdb_remove(mine, on->retrans_list);
1487 ospf6_lsa_delete(his);
1488 }
1489
1490 assert(p == OSPF6_MESSAGE_END(oh));
1491 }
1492
1493 static uint8_t *recvbuf = NULL;
1494 static uint8_t *sendbuf = NULL;
1495 static unsigned int iobuflen = 0;
1496
1497 int ospf6_iobuf_size(unsigned int size)
1498 {
1499 uint8_t *recvnew, *sendnew;
1500
1501 if (size <= iobuflen)
1502 return iobuflen;
1503
1504 recvnew = XMALLOC(MTYPE_OSPF6_MESSAGE, size);
1505 sendnew = XMALLOC(MTYPE_OSPF6_MESSAGE, size);
1506 if (recvnew == NULL || sendnew == NULL) {
1507 if (recvnew)
1508 XFREE(MTYPE_OSPF6_MESSAGE, recvnew);
1509 if (sendnew)
1510 XFREE(MTYPE_OSPF6_MESSAGE, sendnew);
1511 zlog_debug("Could not allocate I/O buffer of size %d.", size);
1512 return iobuflen;
1513 }
1514
1515 if (recvbuf)
1516 XFREE(MTYPE_OSPF6_MESSAGE, recvbuf);
1517 if (sendbuf)
1518 XFREE(MTYPE_OSPF6_MESSAGE, sendbuf);
1519 recvbuf = recvnew;
1520 sendbuf = sendnew;
1521 iobuflen = size;
1522
1523 return iobuflen;
1524 }
1525
1526 void ospf6_message_terminate(void)
1527 {
1528 if (recvbuf) {
1529 XFREE(MTYPE_OSPF6_MESSAGE, recvbuf);
1530 recvbuf = NULL;
1531 }
1532
1533 if (sendbuf) {
1534 XFREE(MTYPE_OSPF6_MESSAGE, sendbuf);
1535 sendbuf = NULL;
1536 }
1537
1538 iobuflen = 0;
1539 }
1540
1541 int ospf6_receive(struct thread *thread)
1542 {
1543 int sockfd;
1544 unsigned int len;
1545 char srcname[64], dstname[64];
1546 struct in6_addr src, dst;
1547 ifindex_t ifindex;
1548 struct iovec iovector[2];
1549 struct ospf6_interface *oi;
1550 struct ospf6_header *oh;
1551
1552 /* add next read thread */
1553 sockfd = THREAD_FD(thread);
1554 thread_add_read(master, ospf6_receive, NULL, sockfd, NULL);
1555
1556 /* initialize */
1557 memset(&src, 0, sizeof(src));
1558 memset(&dst, 0, sizeof(dst));
1559 ifindex = 0;
1560 memset(recvbuf, 0, iobuflen);
1561 iovector[0].iov_base = recvbuf;
1562 iovector[0].iov_len = iobuflen;
1563 iovector[1].iov_base = NULL;
1564 iovector[1].iov_len = 0;
1565
1566 /* receive message */
1567 len = ospf6_recvmsg(&src, &dst, &ifindex, iovector);
1568 if (len > iobuflen) {
1569 zlog_err("Excess message read");
1570 return 0;
1571 }
1572
1573 oi = ospf6_interface_lookup_by_ifindex(ifindex);
1574 if (oi == NULL || oi->area == NULL
1575 || CHECK_FLAG(oi->flag, OSPF6_INTERFACE_DISABLE)) {
1576 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
1577 zlog_debug("Message received on disabled interface");
1578 return 0;
1579 }
1580 if (CHECK_FLAG(oi->flag, OSPF6_INTERFACE_PASSIVE)) {
1581 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
1582 zlog_debug("%s: Ignore message on passive interface %s",
1583 __func__, oi->interface->name);
1584 return 0;
1585 }
1586
1587 oh = (struct ospf6_header *)recvbuf;
1588 if (ospf6_rxpacket_examin(oi, oh, len) != MSG_OK)
1589 return 0;
1590
1591 /* Being here means, that no sizing/alignment issues were detected in
1592 the input packet. This renders the additional checks performed below
1593 and also in the type-specific dispatching functions a dead code,
1594 which can be dismissed in a cleanup-focused review round later. */
1595
1596 /* Log */
1597 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, RECV)) {
1598 inet_ntop(AF_INET6, &src, srcname, sizeof(srcname));
1599 inet_ntop(AF_INET6, &dst, dstname, sizeof(dstname));
1600 zlog_debug("%s received on %s",
1601 lookup_msg(ospf6_message_type_str, oh->type, NULL),
1602 oi->interface->name);
1603 zlog_debug(" src: %s", srcname);
1604 zlog_debug(" dst: %s", dstname);
1605
1606 switch (oh->type) {
1607 case OSPF6_MESSAGE_TYPE_HELLO:
1608 ospf6_hello_print(oh);
1609 break;
1610 case OSPF6_MESSAGE_TYPE_DBDESC:
1611 ospf6_dbdesc_print(oh);
1612 break;
1613 case OSPF6_MESSAGE_TYPE_LSREQ:
1614 ospf6_lsreq_print(oh);
1615 break;
1616 case OSPF6_MESSAGE_TYPE_LSUPDATE:
1617 ospf6_lsupdate_print(oh);
1618 break;
1619 case OSPF6_MESSAGE_TYPE_LSACK:
1620 ospf6_lsack_print(oh);
1621 break;
1622 default:
1623 assert(0);
1624 }
1625 }
1626
1627 switch (oh->type) {
1628 case OSPF6_MESSAGE_TYPE_HELLO:
1629 ospf6_hello_recv(&src, &dst, oi, oh);
1630 break;
1631
1632 case OSPF6_MESSAGE_TYPE_DBDESC:
1633 ospf6_dbdesc_recv(&src, &dst, oi, oh);
1634 break;
1635
1636 case OSPF6_MESSAGE_TYPE_LSREQ:
1637 ospf6_lsreq_recv(&src, &dst, oi, oh);
1638 break;
1639
1640 case OSPF6_MESSAGE_TYPE_LSUPDATE:
1641 ospf6_lsupdate_recv(&src, &dst, oi, oh);
1642 break;
1643
1644 case OSPF6_MESSAGE_TYPE_LSACK:
1645 ospf6_lsack_recv(&src, &dst, oi, oh);
1646 break;
1647
1648 default:
1649 assert(0);
1650 }
1651
1652 return 0;
1653 }
1654
1655 static void ospf6_send(struct in6_addr *src, struct in6_addr *dst,
1656 struct ospf6_interface *oi, struct ospf6_header *oh)
1657 {
1658 unsigned int len;
1659 char srcname[64], dstname[64];
1660 struct iovec iovector[2];
1661
1662 /* initialize */
1663 iovector[0].iov_base = (caddr_t)oh;
1664 iovector[0].iov_len = ntohs(oh->length);
1665 iovector[1].iov_base = NULL;
1666 iovector[1].iov_len = 0;
1667
1668 /* fill OSPF header */
1669 oh->version = OSPFV3_VERSION;
1670 /* message type must be set before */
1671 /* message length must be set before */
1672 oh->router_id = oi->area->ospf6->router_id;
1673 oh->area_id = oi->area->area_id;
1674 /* checksum is calculated by kernel */
1675 oh->instance_id = oi->instance_id;
1676 oh->reserved = 0;
1677
1678 /* Log */
1679 if (IS_OSPF6_DEBUG_MESSAGE(oh->type, SEND)) {
1680 inet_ntop(AF_INET6, dst, dstname, sizeof(dstname));
1681 if (src)
1682 inet_ntop(AF_INET6, src, srcname, sizeof(srcname));
1683 else
1684 memset(srcname, 0, sizeof(srcname));
1685 zlog_debug("%s send on %s",
1686 lookup_msg(ospf6_message_type_str, oh->type, NULL),
1687 oi->interface->name);
1688 zlog_debug(" src: %s", srcname);
1689 zlog_debug(" dst: %s", dstname);
1690
1691 switch (oh->type) {
1692 case OSPF6_MESSAGE_TYPE_HELLO:
1693 ospf6_hello_print(oh);
1694 break;
1695 case OSPF6_MESSAGE_TYPE_DBDESC:
1696 ospf6_dbdesc_print(oh);
1697 break;
1698 case OSPF6_MESSAGE_TYPE_LSREQ:
1699 ospf6_lsreq_print(oh);
1700 break;
1701 case OSPF6_MESSAGE_TYPE_LSUPDATE:
1702 ospf6_lsupdate_print(oh);
1703 break;
1704 case OSPF6_MESSAGE_TYPE_LSACK:
1705 ospf6_lsack_print(oh);
1706 break;
1707 default:
1708 zlog_debug("Unknown message");
1709 assert(0);
1710 break;
1711 }
1712 }
1713
1714 /* send message */
1715 len = ospf6_sendmsg(src, dst, &oi->interface->ifindex, iovector);
1716 if (len != ntohs(oh->length))
1717 zlog_err("Could not send entire message");
1718 }
1719
1720 static uint32_t ospf6_packet_max(struct ospf6_interface *oi)
1721 {
1722 assert(oi->ifmtu > sizeof(struct ip6_hdr));
1723 return oi->ifmtu - (sizeof(struct ip6_hdr));
1724 }
1725
1726 int ospf6_hello_send(struct thread *thread)
1727 {
1728 struct ospf6_interface *oi;
1729 struct ospf6_header *oh;
1730 struct ospf6_hello *hello;
1731 uint8_t *p;
1732 struct listnode *node, *nnode;
1733 struct ospf6_neighbor *on;
1734
1735 oi = (struct ospf6_interface *)THREAD_ARG(thread);
1736 oi->thread_send_hello = (struct thread *)NULL;
1737
1738 if (oi->state <= OSPF6_INTERFACE_DOWN) {
1739 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_HELLO, SEND))
1740 zlog_debug("Unable to send Hello on down interface %s",
1741 oi->interface->name);
1742 return 0;
1743 }
1744
1745 if (iobuflen == 0) {
1746 zlog_debug("Unable to send Hello on interface %s iobuflen is 0",
1747 oi->interface->name);
1748 return 0;
1749 }
1750
1751 /* set next thread */
1752 thread_add_timer(master, ospf6_hello_send, oi, oi->hello_interval,
1753 &oi->thread_send_hello);
1754
1755 memset(sendbuf, 0, iobuflen);
1756 oh = (struct ospf6_header *)sendbuf;
1757 hello = (struct ospf6_hello *)((caddr_t)oh
1758 + sizeof(struct ospf6_header));
1759
1760 hello->interface_id = htonl(oi->interface->ifindex);
1761 hello->priority = oi->priority;
1762 hello->options[0] = oi->area->options[0];
1763 hello->options[1] = oi->area->options[1];
1764 hello->options[2] = oi->area->options[2];
1765 hello->hello_interval = htons(oi->hello_interval);
1766 hello->dead_interval = htons(oi->dead_interval);
1767 hello->drouter = oi->drouter;
1768 hello->bdrouter = oi->bdrouter;
1769
1770 p = (uint8_t *)((caddr_t)hello + sizeof(struct ospf6_hello));
1771
1772 for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) {
1773 if (on->state < OSPF6_NEIGHBOR_INIT)
1774 continue;
1775
1776 if (p - sendbuf + sizeof(uint32_t) > ospf6_packet_max(oi)) {
1777 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_HELLO,
1778 SEND))
1779 zlog_debug(
1780 "sending Hello message: exceeds I/F MTU");
1781 break;
1782 }
1783
1784 memcpy(p, &on->router_id, sizeof(uint32_t));
1785 p += sizeof(uint32_t);
1786 }
1787
1788 oh->type = OSPF6_MESSAGE_TYPE_HELLO;
1789 oh->length = htons(p - sendbuf);
1790
1791 oi->hello_out++;
1792
1793 ospf6_send(oi->linklocal_addr, &allspfrouters6, oi, oh);
1794 return 0;
1795 }
1796
1797 int ospf6_dbdesc_send(struct thread *thread)
1798 {
1799 struct ospf6_neighbor *on;
1800 struct ospf6_header *oh;
1801 struct ospf6_dbdesc *dbdesc;
1802 uint8_t *p;
1803 struct ospf6_lsa *lsa;
1804 struct in6_addr *dst;
1805
1806 on = (struct ospf6_neighbor *)THREAD_ARG(thread);
1807 on->thread_send_dbdesc = (struct thread *)NULL;
1808
1809 if (on->state < OSPF6_NEIGHBOR_EXSTART) {
1810 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_DBDESC, SEND))
1811 zlog_debug(
1812 "Quit to send DbDesc to neighbor %s state %s",
1813 on->name, ospf6_neighbor_state_str[on->state]);
1814 return 0;
1815 }
1816
1817 /* set next thread if master */
1818 if (CHECK_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MSBIT))
1819 thread_add_timer(master, ospf6_dbdesc_send, on,
1820 on->ospf6_if->rxmt_interval,
1821 &on->thread_send_dbdesc);
1822
1823 memset(sendbuf, 0, iobuflen);
1824 oh = (struct ospf6_header *)sendbuf;
1825 dbdesc = (struct ospf6_dbdesc *)((caddr_t)oh
1826 + sizeof(struct ospf6_header));
1827
1828 /* if this is initial one, initialize sequence number for DbDesc */
1829 if (CHECK_FLAG(on->dbdesc_bits, OSPF6_DBDESC_IBIT)
1830 && (on->dbdesc_seqnum == 0)) {
1831 on->dbdesc_seqnum = monotime(NULL);
1832 }
1833
1834 dbdesc->options[0] = on->ospf6_if->area->options[0];
1835 dbdesc->options[1] = on->ospf6_if->area->options[1];
1836 dbdesc->options[2] = on->ospf6_if->area->options[2];
1837 dbdesc->ifmtu = htons(on->ospf6_if->ifmtu);
1838 dbdesc->bits = on->dbdesc_bits;
1839 dbdesc->seqnum = htonl(on->dbdesc_seqnum);
1840
1841 /* if this is not initial one, set LSA headers in dbdesc */
1842 p = (uint8_t *)((caddr_t)dbdesc + sizeof(struct ospf6_dbdesc));
1843 if (!CHECK_FLAG(on->dbdesc_bits, OSPF6_DBDESC_IBIT)) {
1844 for (ALL_LSDB(on->dbdesc_list, lsa)) {
1845 ospf6_lsa_age_update_to_send(lsa,
1846 on->ospf6_if->transdelay);
1847
1848 /* MTU check */
1849 if (p - sendbuf + sizeof(struct ospf6_lsa_header)
1850 > ospf6_packet_max(on->ospf6_if)) {
1851 ospf6_lsdb_lsa_unlock(lsa);
1852 break;
1853 }
1854 memcpy(p, lsa->header, sizeof(struct ospf6_lsa_header));
1855 p += sizeof(struct ospf6_lsa_header);
1856 }
1857 }
1858
1859 oh->type = OSPF6_MESSAGE_TYPE_DBDESC;
1860 oh->length = htons(p - sendbuf);
1861
1862
1863 if (on->ospf6_if->state == OSPF6_INTERFACE_POINTTOPOINT)
1864 dst = &allspfrouters6;
1865 else
1866 dst = &on->linklocal_addr;
1867
1868 on->ospf6_if->db_desc_out++;
1869
1870 ospf6_send(on->ospf6_if->linklocal_addr, dst, on->ospf6_if, oh);
1871
1872 return 0;
1873 }
1874
1875 int ospf6_dbdesc_send_newone(struct thread *thread)
1876 {
1877 struct ospf6_neighbor *on;
1878 struct ospf6_lsa *lsa;
1879 unsigned int size = 0;
1880
1881 on = (struct ospf6_neighbor *)THREAD_ARG(thread);
1882 ospf6_lsdb_remove_all(on->dbdesc_list);
1883
1884 /* move LSAs from summary_list to dbdesc_list (within neighbor
1885 structure)
1886 so that ospf6_send_dbdesc () can send those LSAs */
1887 size = sizeof(struct ospf6_lsa_header) + sizeof(struct ospf6_dbdesc);
1888 for (ALL_LSDB(on->summary_list, lsa)) {
1889 if (size + sizeof(struct ospf6_lsa_header)
1890 > ospf6_packet_max(on->ospf6_if)) {
1891 ospf6_lsdb_lsa_unlock(lsa);
1892 break;
1893 }
1894
1895 ospf6_lsdb_add(ospf6_lsa_copy(lsa), on->dbdesc_list);
1896 ospf6_lsdb_remove(lsa, on->summary_list);
1897 size += sizeof(struct ospf6_lsa_header);
1898 }
1899
1900 if (on->summary_list->count == 0)
1901 UNSET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MBIT);
1902
1903 /* If slave, More bit check must be done here */
1904 if (!CHECK_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MSBIT) && /* Slave */
1905 !CHECK_FLAG(on->dbdesc_last.bits, OSPF6_DBDESC_MBIT)
1906 && !CHECK_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MBIT))
1907 thread_add_event(master, exchange_done, on, 0, NULL);
1908
1909 thread_execute(master, ospf6_dbdesc_send, on, 0);
1910 return 0;
1911 }
1912
1913 int ospf6_lsreq_send(struct thread *thread)
1914 {
1915 struct ospf6_neighbor *on;
1916 struct ospf6_header *oh;
1917 struct ospf6_lsreq_entry *e;
1918 uint8_t *p;
1919 struct ospf6_lsa *lsa, *last_req;
1920
1921 on = (struct ospf6_neighbor *)THREAD_ARG(thread);
1922 on->thread_send_lsreq = (struct thread *)NULL;
1923
1924 /* LSReq will be sent only in ExStart or Loading */
1925 if (on->state != OSPF6_NEIGHBOR_EXCHANGE
1926 && on->state != OSPF6_NEIGHBOR_LOADING) {
1927 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_LSREQ, SEND))
1928 zlog_debug("Quit to send LSReq to neighbor %s state %s",
1929 on->name,
1930 ospf6_neighbor_state_str[on->state]);
1931 return 0;
1932 }
1933
1934 /* schedule loading_done if request list is empty */
1935 if (on->request_list->count == 0) {
1936 thread_add_event(master, loading_done, on, 0, NULL);
1937 return 0;
1938 }
1939
1940 memset(sendbuf, 0, iobuflen);
1941 oh = (struct ospf6_header *)sendbuf;
1942 last_req = NULL;
1943
1944 /* set Request entries in lsreq */
1945 p = (uint8_t *)((caddr_t)oh + sizeof(struct ospf6_header));
1946 for (ALL_LSDB(on->request_list, lsa)) {
1947 /* MTU check */
1948 if (p - sendbuf + sizeof(struct ospf6_lsreq_entry)
1949 > ospf6_packet_max(on->ospf6_if)) {
1950 ospf6_lsdb_lsa_unlock(lsa);
1951 break;
1952 }
1953
1954 e = (struct ospf6_lsreq_entry *)p;
1955 e->type = lsa->header->type;
1956 e->id = lsa->header->id;
1957 e->adv_router = lsa->header->adv_router;
1958 p += sizeof(struct ospf6_lsreq_entry);
1959 last_req = lsa;
1960 }
1961
1962 if (last_req != NULL) {
1963 if (on->last_ls_req != NULL) {
1964 ospf6_lsa_unlock(on->last_ls_req);
1965 }
1966 ospf6_lsa_lock(last_req);
1967 on->last_ls_req = last_req;
1968 }
1969
1970 oh->type = OSPF6_MESSAGE_TYPE_LSREQ;
1971 oh->length = htons(p - sendbuf);
1972
1973 on->ospf6_if->ls_req_out++;
1974
1975 if (on->ospf6_if->state == OSPF6_INTERFACE_POINTTOPOINT)
1976 ospf6_send(on->ospf6_if->linklocal_addr, &allspfrouters6,
1977 on->ospf6_if, oh);
1978 else
1979 ospf6_send(on->ospf6_if->linklocal_addr, &on->linklocal_addr,
1980 on->ospf6_if, oh);
1981
1982 /* set next thread */
1983 if (on->request_list->count != 0) {
1984 on->thread_send_lsreq = NULL;
1985 thread_add_timer(master, ospf6_lsreq_send, on,
1986 on->ospf6_if->rxmt_interval,
1987 &on->thread_send_lsreq);
1988 }
1989
1990 return 0;
1991 }
1992
1993 static void ospf6_send_lsupdate(struct ospf6_neighbor *on,
1994 struct ospf6_interface *oi,
1995 struct ospf6_header *oh)
1996 {
1997
1998 if (on) {
1999 on->ospf6_if->ls_upd_out++;
2000
2001 if ((on->ospf6_if->state == OSPF6_INTERFACE_POINTTOPOINT)
2002 || (on->ospf6_if->state == OSPF6_INTERFACE_DR)
2003 || (on->ospf6_if->state == OSPF6_INTERFACE_BDR)) {
2004 ospf6_send(on->ospf6_if->linklocal_addr,
2005 &allspfrouters6, on->ospf6_if, oh);
2006 } else {
2007 ospf6_send(on->ospf6_if->linklocal_addr,
2008 &on->linklocal_addr, on->ospf6_if, oh);
2009 }
2010 } else if (oi) {
2011
2012 oi->ls_upd_out++;
2013
2014 if ((oi->state == OSPF6_INTERFACE_POINTTOPOINT)
2015 || (oi->state == OSPF6_INTERFACE_DR)
2016 || (oi->state == OSPF6_INTERFACE_BDR)) {
2017 ospf6_send(oi->linklocal_addr, &allspfrouters6, oi, oh);
2018 } else {
2019 ospf6_send(oi->linklocal_addr, &alldrouters6, oi, oh);
2020 }
2021 }
2022 }
2023
2024 int ospf6_lsupdate_send_neighbor(struct thread *thread)
2025 {
2026 struct ospf6_neighbor *on;
2027 struct ospf6_header *oh;
2028 struct ospf6_lsupdate *lsupdate;
2029 uint8_t *p;
2030 int lsa_cnt;
2031 struct ospf6_lsa *lsa;
2032
2033 on = (struct ospf6_neighbor *)THREAD_ARG(thread);
2034 on->thread_send_lsupdate = (struct thread *)NULL;
2035
2036 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_LSUPDATE, SEND))
2037 zlog_debug("LSUpdate to neighbor %s", on->name);
2038
2039 if (on->state < OSPF6_NEIGHBOR_EXCHANGE) {
2040 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_LSUPDATE, SEND))
2041 zlog_debug("Quit to send (neighbor state %s)",
2042 ospf6_neighbor_state_str[on->state]);
2043 return 0;
2044 }
2045
2046 memset(sendbuf, 0, iobuflen);
2047 oh = (struct ospf6_header *)sendbuf;
2048 lsupdate = (struct ospf6_lsupdate *)((caddr_t)oh
2049 + sizeof(struct ospf6_header));
2050
2051 p = (uint8_t *)((caddr_t)lsupdate + sizeof(struct ospf6_lsupdate));
2052 lsa_cnt = 0;
2053
2054 /* lsupdate_list lists those LSA which doesn't need to be
2055 retransmitted. remove those from the list */
2056 for (ALL_LSDB(on->lsupdate_list, lsa)) {
2057 /* MTU check */
2058 if ((p - sendbuf + (unsigned int)OSPF6_LSA_SIZE(lsa->header))
2059 > ospf6_packet_max(on->ospf6_if)) {
2060 if (lsa_cnt) {
2061 oh->type = OSPF6_MESSAGE_TYPE_LSUPDATE;
2062 oh->length = htons(p - sendbuf);
2063 lsupdate->lsa_number = htonl(lsa_cnt);
2064
2065 ospf6_send_lsupdate(on, NULL, oh);
2066
2067 memset(sendbuf, 0, iobuflen);
2068 oh = (struct ospf6_header *)sendbuf;
2069 lsupdate = (struct ospf6_lsupdate
2070 *)((caddr_t)oh
2071 + sizeof(struct
2072 ospf6_header));
2073
2074 p = (uint8_t *)((caddr_t)lsupdate
2075 + sizeof(struct
2076 ospf6_lsupdate));
2077 lsa_cnt = 0;
2078 }
2079 }
2080
2081 ospf6_lsa_age_update_to_send(lsa, on->ospf6_if->transdelay);
2082 memcpy(p, lsa->header, OSPF6_LSA_SIZE(lsa->header));
2083 p += OSPF6_LSA_SIZE(lsa->header);
2084 lsa_cnt++;
2085
2086 assert(lsa->lock == 2);
2087 ospf6_lsdb_remove(lsa, on->lsupdate_list);
2088 }
2089
2090 if (lsa_cnt) {
2091 oh->type = OSPF6_MESSAGE_TYPE_LSUPDATE;
2092 oh->length = htons(p - sendbuf);
2093 lsupdate->lsa_number = htonl(lsa_cnt);
2094 ospf6_send_lsupdate(on, NULL, oh);
2095 }
2096
2097 /* The addresses used for retransmissions are different from those sent
2098 the
2099 first time and so we need to separate them here.
2100 */
2101 memset(sendbuf, 0, iobuflen);
2102 oh = (struct ospf6_header *)sendbuf;
2103 lsupdate = (struct ospf6_lsupdate *)((caddr_t)oh
2104 + sizeof(struct ospf6_header));
2105 p = (uint8_t *)((caddr_t)lsupdate + sizeof(struct ospf6_lsupdate));
2106 lsa_cnt = 0;
2107
2108 for (ALL_LSDB(on->retrans_list, lsa)) {
2109 /* MTU check */
2110 if ((p - sendbuf + (unsigned int)OSPF6_LSA_SIZE(lsa->header))
2111 > ospf6_packet_max(on->ospf6_if)) {
2112 if (lsa_cnt) {
2113 oh->type = OSPF6_MESSAGE_TYPE_LSUPDATE;
2114 oh->length = htons(p - sendbuf);
2115 lsupdate->lsa_number = htonl(lsa_cnt);
2116
2117 if (on->ospf6_if->state
2118 == OSPF6_INTERFACE_POINTTOPOINT) {
2119 ospf6_send(on->ospf6_if->linklocal_addr,
2120 &allspfrouters6,
2121 on->ospf6_if, oh);
2122 } else {
2123 ospf6_send(on->ospf6_if->linklocal_addr,
2124 &on->linklocal_addr,
2125 on->ospf6_if, oh);
2126 }
2127
2128 memset(sendbuf, 0, iobuflen);
2129 oh = (struct ospf6_header *)sendbuf;
2130 lsupdate = (struct ospf6_lsupdate
2131 *)((caddr_t)oh
2132 + sizeof(struct
2133 ospf6_header));
2134 p = (uint8_t *)((caddr_t)lsupdate
2135 + sizeof(struct
2136 ospf6_lsupdate));
2137 lsa_cnt = 0;
2138 }
2139 }
2140
2141 ospf6_lsa_age_update_to_send(lsa, on->ospf6_if->transdelay);
2142 memcpy(p, lsa->header, OSPF6_LSA_SIZE(lsa->header));
2143 p += OSPF6_LSA_SIZE(lsa->header);
2144 lsa_cnt++;
2145 }
2146
2147 if (lsa_cnt) {
2148 oh->type = OSPF6_MESSAGE_TYPE_LSUPDATE;
2149 oh->length = htons(p - sendbuf);
2150 lsupdate->lsa_number = htonl(lsa_cnt);
2151
2152 if (on->ospf6_if->state == OSPF6_INTERFACE_POINTTOPOINT)
2153 ospf6_send(on->ospf6_if->linklocal_addr,
2154 &allspfrouters6, on->ospf6_if, oh);
2155 else
2156 ospf6_send(on->ospf6_if->linklocal_addr,
2157 &on->linklocal_addr, on->ospf6_if, oh);
2158 }
2159
2160 if (on->lsupdate_list->count != 0) {
2161 on->thread_send_lsupdate = NULL;
2162 thread_add_event(master, ospf6_lsupdate_send_neighbor, on, 0,
2163 &on->thread_send_lsupdate);
2164 } else if (on->retrans_list->count != 0) {
2165 on->thread_send_lsupdate = NULL;
2166 thread_add_timer(master, ospf6_lsupdate_send_neighbor, on,
2167 on->ospf6_if->rxmt_interval,
2168 &on->thread_send_lsupdate);
2169 }
2170 return 0;
2171 }
2172
2173 int ospf6_lsupdate_send_neighbor_now(struct ospf6_neighbor *on,
2174 struct ospf6_lsa *lsa)
2175 {
2176 struct ospf6_header *oh;
2177 struct ospf6_lsupdate *lsupdate;
2178 uint8_t *p;
2179 int lsa_cnt = 0;
2180
2181 memset(sendbuf, 0, iobuflen);
2182 oh = (struct ospf6_header *)sendbuf;
2183 lsupdate = (struct ospf6_lsupdate *)((caddr_t)oh
2184 + sizeof(struct ospf6_header));
2185
2186 p = (uint8_t *)((caddr_t)lsupdate + sizeof(struct ospf6_lsupdate));
2187 ospf6_lsa_age_update_to_send(lsa, on->ospf6_if->transdelay);
2188 memcpy(p, lsa->header, OSPF6_LSA_SIZE(lsa->header));
2189 p += OSPF6_LSA_SIZE(lsa->header);
2190 lsa_cnt++;
2191
2192 oh->type = OSPF6_MESSAGE_TYPE_LSUPDATE;
2193 oh->length = htons(p - sendbuf);
2194 lsupdate->lsa_number = htonl(lsa_cnt);
2195
2196 if (IS_OSPF6_DEBUG_FLOODING
2197 || IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_LSUPDATE, SEND))
2198 zlog_debug("%s: Send lsupdate with lsa %s (age %u)",
2199 __PRETTY_FUNCTION__, lsa->name,
2200 ntohs(lsa->header->age));
2201
2202 ospf6_send_lsupdate(on, NULL, oh);
2203
2204 return 0;
2205 }
2206
2207 int ospf6_lsupdate_send_interface(struct thread *thread)
2208 {
2209 struct ospf6_interface *oi;
2210 struct ospf6_header *oh;
2211 struct ospf6_lsupdate *lsupdate;
2212 uint8_t *p;
2213 int lsa_cnt;
2214 struct ospf6_lsa *lsa;
2215
2216 oi = (struct ospf6_interface *)THREAD_ARG(thread);
2217 oi->thread_send_lsupdate = (struct thread *)NULL;
2218
2219 if (oi->state <= OSPF6_INTERFACE_WAITING) {
2220 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_LSUPDATE, SEND))
2221 zlog_debug(
2222 "Quit to send LSUpdate to interface %s state %s",
2223 oi->interface->name,
2224 ospf6_interface_state_str[oi->state]);
2225 return 0;
2226 }
2227
2228 /* if we have nothing to send, return */
2229 if (oi->lsupdate_list->count == 0)
2230 return 0;
2231
2232 memset(sendbuf, 0, iobuflen);
2233 oh = (struct ospf6_header *)sendbuf;
2234 lsupdate = (struct ospf6_lsupdate *)((caddr_t)oh
2235 + sizeof(struct ospf6_header));
2236
2237 p = (uint8_t *)((caddr_t)lsupdate + sizeof(struct ospf6_lsupdate));
2238 lsa_cnt = 0;
2239
2240 for (ALL_LSDB(oi->lsupdate_list, lsa)) {
2241 /* MTU check */
2242 if ((p - sendbuf + ((unsigned int)OSPF6_LSA_SIZE(lsa->header)))
2243 > ospf6_packet_max(oi)) {
2244 if (lsa_cnt) {
2245 oh->type = OSPF6_MESSAGE_TYPE_LSUPDATE;
2246 oh->length = htons(p - sendbuf);
2247 lsupdate->lsa_number = htonl(lsa_cnt);
2248
2249 ospf6_send_lsupdate(NULL, oi, oh);
2250 if (IS_OSPF6_DEBUG_MESSAGE(
2251 OSPF6_MESSAGE_TYPE_LSUPDATE, SEND))
2252 zlog_debug("%s: LSUpdate length %d",
2253 __PRETTY_FUNCTION__,
2254 ntohs(oh->length));
2255
2256 memset(sendbuf, 0, iobuflen);
2257 oh = (struct ospf6_header *)sendbuf;
2258 lsupdate = (struct ospf6_lsupdate
2259 *)((caddr_t)oh
2260 + sizeof(struct
2261 ospf6_header));
2262
2263 p = (uint8_t *)((caddr_t)lsupdate
2264 + sizeof(struct
2265 ospf6_lsupdate));
2266 lsa_cnt = 0;
2267 }
2268 }
2269
2270 ospf6_lsa_age_update_to_send(lsa, oi->transdelay);
2271 memcpy(p, lsa->header, OSPF6_LSA_SIZE(lsa->header));
2272 p += OSPF6_LSA_SIZE(lsa->header);
2273 lsa_cnt++;
2274
2275 assert(lsa->lock == 2);
2276 ospf6_lsdb_remove(lsa, oi->lsupdate_list);
2277 }
2278
2279 if (lsa_cnt) {
2280 oh->type = OSPF6_MESSAGE_TYPE_LSUPDATE;
2281 oh->length = htons(p - sendbuf);
2282 lsupdate->lsa_number = htonl(lsa_cnt);
2283
2284 ospf6_send_lsupdate(NULL, oi, oh);
2285 }
2286
2287 if (oi->lsupdate_list->count > 0) {
2288 oi->thread_send_lsupdate = NULL;
2289 thread_add_event(master, ospf6_lsupdate_send_interface, oi, 0,
2290 &oi->thread_send_lsupdate);
2291 }
2292
2293 return 0;
2294 }
2295
2296 int ospf6_lsack_send_neighbor(struct thread *thread)
2297 {
2298 struct ospf6_neighbor *on;
2299 struct ospf6_header *oh;
2300 uint8_t *p;
2301 struct ospf6_lsa *lsa;
2302 int lsa_cnt = 0;
2303
2304 on = (struct ospf6_neighbor *)THREAD_ARG(thread);
2305 on->thread_send_lsack = (struct thread *)NULL;
2306
2307 if (on->state < OSPF6_NEIGHBOR_EXCHANGE) {
2308 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_LSACK, SEND))
2309 zlog_debug("Quit to send LSAck to neighbor %s state %s",
2310 on->name,
2311 ospf6_neighbor_state_str[on->state]);
2312 return 0;
2313 }
2314
2315 /* if we have nothing to send, return */
2316 if (on->lsack_list->count == 0)
2317 return 0;
2318
2319 memset(sendbuf, 0, iobuflen);
2320 oh = (struct ospf6_header *)sendbuf;
2321
2322 p = (uint8_t *)((caddr_t)oh + sizeof(struct ospf6_header));
2323
2324 for (ALL_LSDB(on->lsack_list, lsa)) {
2325 /* MTU check */
2326 if (p - sendbuf + sizeof(struct ospf6_lsa_header)
2327 > ospf6_packet_max(on->ospf6_if)) {
2328 /* if we run out of packet size/space here,
2329 better to try again soon. */
2330 if (lsa_cnt) {
2331 oh->type = OSPF6_MESSAGE_TYPE_LSACK;
2332 oh->length = htons(p - sendbuf);
2333
2334 on->ospf6_if->ls_ack_out++;
2335
2336 ospf6_send(on->ospf6_if->linklocal_addr,
2337 &on->linklocal_addr, on->ospf6_if,
2338 oh);
2339
2340 memset(sendbuf, 0, iobuflen);
2341 oh = (struct ospf6_header *)sendbuf;
2342 p = (uint8_t *)((caddr_t)oh
2343 + sizeof(struct ospf6_header));
2344 lsa_cnt = 0;
2345 }
2346 }
2347
2348 ospf6_lsa_age_update_to_send(lsa, on->ospf6_if->transdelay);
2349 memcpy(p, lsa->header, sizeof(struct ospf6_lsa_header));
2350 p += sizeof(struct ospf6_lsa_header);
2351
2352 assert(lsa->lock == 2);
2353 ospf6_lsdb_remove(lsa, on->lsack_list);
2354 lsa_cnt++;
2355 }
2356
2357 if (lsa_cnt) {
2358 oh->type = OSPF6_MESSAGE_TYPE_LSACK;
2359 oh->length = htons(p - sendbuf);
2360
2361 on->ospf6_if->ls_ack_out++;
2362
2363 ospf6_send(on->ospf6_if->linklocal_addr, &on->linklocal_addr,
2364 on->ospf6_if, oh);
2365 }
2366
2367 if (on->lsack_list->count > 0)
2368 thread_add_event(master, ospf6_lsack_send_neighbor, on, 0,
2369 &on->thread_send_lsack);
2370
2371 return 0;
2372 }
2373
2374 int ospf6_lsack_send_interface(struct thread *thread)
2375 {
2376 struct ospf6_interface *oi;
2377 struct ospf6_header *oh;
2378 uint8_t *p;
2379 struct ospf6_lsa *lsa;
2380 int lsa_cnt = 0;
2381
2382 oi = (struct ospf6_interface *)THREAD_ARG(thread);
2383 oi->thread_send_lsack = (struct thread *)NULL;
2384
2385 if (oi->state <= OSPF6_INTERFACE_WAITING) {
2386 if (IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_LSACK, SEND))
2387 zlog_debug(
2388 "Quit to send LSAck to interface %s state %s",
2389 oi->interface->name,
2390 ospf6_interface_state_str[oi->state]);
2391 return 0;
2392 }
2393
2394 /* if we have nothing to send, return */
2395 if (oi->lsack_list->count == 0)
2396 return 0;
2397
2398 memset(sendbuf, 0, iobuflen);
2399 oh = (struct ospf6_header *)sendbuf;
2400
2401 p = (uint8_t *)((caddr_t)oh + sizeof(struct ospf6_header));
2402
2403 for (ALL_LSDB(oi->lsack_list, lsa)) {
2404 /* MTU check */
2405 if (p - sendbuf + sizeof(struct ospf6_lsa_header)
2406 > ospf6_packet_max(oi)) {
2407 /* if we run out of packet size/space here,
2408 better to try again soon. */
2409 THREAD_OFF(oi->thread_send_lsack);
2410 thread_add_event(master, ospf6_lsack_send_interface, oi,
2411 0, &oi->thread_send_lsack);
2412
2413 ospf6_lsdb_lsa_unlock(lsa);
2414 break;
2415 }
2416
2417 ospf6_lsa_age_update_to_send(lsa, oi->transdelay);
2418 memcpy(p, lsa->header, sizeof(struct ospf6_lsa_header));
2419 p += sizeof(struct ospf6_lsa_header);
2420
2421 assert(lsa->lock == 2);
2422 ospf6_lsdb_remove(lsa, oi->lsack_list);
2423 lsa_cnt++;
2424 }
2425
2426 if (lsa_cnt) {
2427 oh->type = OSPF6_MESSAGE_TYPE_LSACK;
2428 oh->length = htons(p - sendbuf);
2429
2430 if ((oi->state == OSPF6_INTERFACE_POINTTOPOINT)
2431 || (oi->state == OSPF6_INTERFACE_DR)
2432 || (oi->state == OSPF6_INTERFACE_BDR))
2433 ospf6_send(oi->linklocal_addr, &allspfrouters6, oi, oh);
2434 else
2435 ospf6_send(oi->linklocal_addr, &alldrouters6, oi, oh);
2436 }
2437
2438 if (oi->lsack_list->count > 0)
2439 thread_add_event(master, ospf6_lsack_send_interface, oi, 0,
2440 &oi->thread_send_lsack);
2441
2442 return 0;
2443 }
2444
2445
2446 /* Commands */
2447 DEFUN (debug_ospf6_message,
2448 debug_ospf6_message_cmd,
2449 "debug ospf6 message <unknown|hello|dbdesc|lsreq|lsupdate|lsack|all> [<send|recv>]",
2450 DEBUG_STR
2451 OSPF6_STR
2452 "Debug OSPFv3 message\n"
2453 "Debug Unknown message\n"
2454 "Debug Hello message\n"
2455 "Debug Database Description message\n"
2456 "Debug Link State Request message\n"
2457 "Debug Link State Update message\n"
2458 "Debug Link State Acknowledgement message\n"
2459 "Debug All message\n"
2460 "Debug only sending message\n"
2461 "Debug only receiving message\n")
2462 {
2463 int idx_packet = 3;
2464 int idx_send_recv = 4;
2465 unsigned char level = 0;
2466 int type = 0;
2467 int i;
2468
2469 /* check type */
2470 if (!strncmp(argv[idx_packet]->arg, "u", 1))
2471 type = OSPF6_MESSAGE_TYPE_UNKNOWN;
2472 else if (!strncmp(argv[idx_packet]->arg, "h", 1))
2473 type = OSPF6_MESSAGE_TYPE_HELLO;
2474 else if (!strncmp(argv[idx_packet]->arg, "d", 1))
2475 type = OSPF6_MESSAGE_TYPE_DBDESC;
2476 else if (!strncmp(argv[idx_packet]->arg, "lsr", 3))
2477 type = OSPF6_MESSAGE_TYPE_LSREQ;
2478 else if (!strncmp(argv[idx_packet]->arg, "lsu", 3))
2479 type = OSPF6_MESSAGE_TYPE_LSUPDATE;
2480 else if (!strncmp(argv[idx_packet]->arg, "lsa", 3))
2481 type = OSPF6_MESSAGE_TYPE_LSACK;
2482 else if (!strncmp(argv[idx_packet]->arg, "a", 1))
2483 type = OSPF6_MESSAGE_TYPE_ALL;
2484
2485 if (argc == 4)
2486 level = OSPF6_DEBUG_MESSAGE_SEND | OSPF6_DEBUG_MESSAGE_RECV;
2487 else if (!strncmp(argv[idx_send_recv]->arg, "s", 1))
2488 level = OSPF6_DEBUG_MESSAGE_SEND;
2489 else if (!strncmp(argv[idx_send_recv]->arg, "r", 1))
2490 level = OSPF6_DEBUG_MESSAGE_RECV;
2491
2492 if (type == OSPF6_MESSAGE_TYPE_ALL) {
2493 for (i = 0; i < 6; i++)
2494 OSPF6_DEBUG_MESSAGE_ON(i, level);
2495 } else
2496 OSPF6_DEBUG_MESSAGE_ON(type, level);
2497
2498 return CMD_SUCCESS;
2499 }
2500
2501 DEFUN (no_debug_ospf6_message,
2502 no_debug_ospf6_message_cmd,
2503 "no debug ospf6 message <unknown|hello|dbdesc|lsreq|lsupdate|lsack|all> [<send|recv>]",
2504 NO_STR
2505 DEBUG_STR
2506 OSPF6_STR
2507 "Debug OSPFv3 message\n"
2508 "Debug Unknown message\n"
2509 "Debug Hello message\n"
2510 "Debug Database Description message\n"
2511 "Debug Link State Request message\n"
2512 "Debug Link State Update message\n"
2513 "Debug Link State Acknowledgement message\n"
2514 "Debug All message\n"
2515 "Debug only sending message\n"
2516 "Debug only receiving message\n")
2517 {
2518 int idx_packet = 4;
2519 int idx_send_recv = 5;
2520 unsigned char level = 0;
2521 int type = 0;
2522 int i;
2523
2524 /* check type */
2525 if (!strncmp(argv[idx_packet]->arg, "u", 1))
2526 type = OSPF6_MESSAGE_TYPE_UNKNOWN;
2527 else if (!strncmp(argv[idx_packet]->arg, "h", 1))
2528 type = OSPF6_MESSAGE_TYPE_HELLO;
2529 else if (!strncmp(argv[idx_packet]->arg, "d", 1))
2530 type = OSPF6_MESSAGE_TYPE_DBDESC;
2531 else if (!strncmp(argv[idx_packet]->arg, "lsr", 3))
2532 type = OSPF6_MESSAGE_TYPE_LSREQ;
2533 else if (!strncmp(argv[idx_packet]->arg, "lsu", 3))
2534 type = OSPF6_MESSAGE_TYPE_LSUPDATE;
2535 else if (!strncmp(argv[idx_packet]->arg, "lsa", 3))
2536 type = OSPF6_MESSAGE_TYPE_LSACK;
2537 else if (!strncmp(argv[idx_packet]->arg, "a", 1))
2538 type = OSPF6_MESSAGE_TYPE_ALL;
2539
2540 if (argc == 5)
2541 level = OSPF6_DEBUG_MESSAGE_SEND | OSPF6_DEBUG_MESSAGE_RECV;
2542 else if (!strncmp(argv[idx_send_recv]->arg, "s", 1))
2543 level = OSPF6_DEBUG_MESSAGE_SEND;
2544 else if (!strncmp(argv[idx_send_recv]->arg, "r", 1))
2545 level = OSPF6_DEBUG_MESSAGE_RECV;
2546
2547 if (type == OSPF6_MESSAGE_TYPE_ALL) {
2548 for (i = 0; i < 6; i++)
2549 OSPF6_DEBUG_MESSAGE_OFF(i, level);
2550 } else
2551 OSPF6_DEBUG_MESSAGE_OFF(type, level);
2552
2553 return CMD_SUCCESS;
2554 }
2555
2556
2557 int config_write_ospf6_debug_message(struct vty *vty)
2558 {
2559 const char *type_str[] = {"unknown", "hello", "dbdesc",
2560 "lsreq", "lsupdate", "lsack"};
2561 unsigned char s = 0, r = 0;
2562 int i;
2563
2564 for (i = 0; i < 6; i++) {
2565 if (IS_OSPF6_DEBUG_MESSAGE(i, SEND))
2566 s |= 1 << i;
2567 if (IS_OSPF6_DEBUG_MESSAGE(i, RECV))
2568 r |= 1 << i;
2569 }
2570
2571 if (s == 0x3f && r == 0x3f) {
2572 vty_out(vty, "debug ospf6 message all\n");
2573 return 0;
2574 }
2575
2576 if (s == 0x3f && r == 0) {
2577 vty_out(vty, "debug ospf6 message all send\n");
2578 return 0;
2579 } else if (s == 0 && r == 0x3f) {
2580 vty_out(vty, "debug ospf6 message all recv\n");
2581 return 0;
2582 }
2583
2584 /* Unknown message is logged by default */
2585 if (!IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, SEND)
2586 && !IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
2587 vty_out(vty, "no debug ospf6 message unknown\n");
2588 else if (!IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, SEND))
2589 vty_out(vty, "no debug ospf6 message unknown send\n");
2590 else if (!IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_UNKNOWN, RECV))
2591 vty_out(vty, "no debug ospf6 message unknown recv\n");
2592
2593 for (i = 1; i < 6; i++) {
2594 if (IS_OSPF6_DEBUG_MESSAGE(i, SEND)
2595 && IS_OSPF6_DEBUG_MESSAGE(i, RECV))
2596 vty_out(vty, "debug ospf6 message %s\n", type_str[i]);
2597 else if (IS_OSPF6_DEBUG_MESSAGE(i, SEND))
2598 vty_out(vty, "debug ospf6 message %s send\n",
2599 type_str[i]);
2600 else if (IS_OSPF6_DEBUG_MESSAGE(i, RECV))
2601 vty_out(vty, "debug ospf6 message %s recv\n",
2602 type_str[i]);
2603 }
2604
2605 return 0;
2606 }
2607
2608 void install_element_ospf6_debug_message(void)
2609 {
2610 install_element(ENABLE_NODE, &debug_ospf6_message_cmd);
2611 install_element(ENABLE_NODE, &no_debug_ospf6_message_cmd);
2612 install_element(CONFIG_NODE, &debug_ospf6_message_cmd);
2613 install_element(CONFIG_NODE, &no_debug_ospf6_message_cmd);
2614 }
FRRouting mirror