]> The Tcpdump Group git mirrors - tcpdump/blob - print-olsr.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
OLSR: Fix a goto before ND_PRINT
[tcpdump] / print-olsr.c
1 /*
2 * Copyright (c) 1998-2007 The TCPDUMP project
3 * Copyright (c) 2009 Florian Forster
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that: (1) source code
7 * distributions retain the above copyright notice and this paragraph
8 * in its entirety, and (2) distributions including binary code include
9 * the above copyright notice and this paragraph in its entirety in
10 * the documentation or other materials provided with the distribution.
11 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND
12 * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
13 * LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
14 * FOR A PARTICULAR PURPOSE.
15 *
16 * Original code by Hannes Gredler <hannes@gredler.at>
17 * IPv6 additions by Florian Forster <octo at verplant.org>
18 */
19
20 /* \summary: Optimized Link State Routing Protocol (OLSR) printer */
21
22 /* specification: RFC 3626 */
23
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include "netdissect-stdinc.h"
29
30 #define ND_LONGJMP_FROM_TCHECK
31 #include "netdissect.h"
32 #include "addrtoname.h"
33 #include "extract.h"
34
35 /*
36 * RFC 3626 common header
37 *
38 * 0 1 2 3
39 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
40 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
41 * | Packet Length | Packet Sequence Number |
42 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
43 * | Message Type | Vtime | Message Size |
44 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
45 * | Originator Address |
46 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
47 * | Time To Live | Hop Count | Message Sequence Number |
48 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
49 * | |
50 * : MESSAGE :
51 * | |
52 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
53 * | Message Type | Vtime | Message Size |
54 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
55 * | Originator Address |
56 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
57 * | Time To Live | Hop Count | Message Sequence Number |
58 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
59 * | |
60 * : MESSAGE :
61 * | |
62 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
63 * : :
64 */
65
66 struct olsr_common {
67 nd_uint16_t packet_len;
68 nd_uint16_t packet_seq;
69 };
70
71 #define OLSR_HELLO_MSG 1 /* rfc3626 */
72 #define OLSR_TC_MSG 2 /* rfc3626 */
73 #define OLSR_MID_MSG 3 /* rfc3626 */
74 #define OLSR_HNA_MSG 4 /* rfc3626 */
75 #define OLSR_POWERINFO_MSG 128
76 #define OLSR_NAMESERVICE_MSG 130
77 #define OLSR_HELLO_LQ_MSG 201 /* LQ extensions olsr.org */
78 #define OLSR_TC_LQ_MSG 202 /* LQ extensions olsr.org */
79
80 static const struct tok olsr_msg_values[] = {
81 { OLSR_HELLO_MSG, "Hello" },
82 { OLSR_TC_MSG, "TC" },
83 { OLSR_MID_MSG, "MID" },
84 { OLSR_HNA_MSG, "HNA" },
85 { OLSR_POWERINFO_MSG, "Powerinfo" },
86 { OLSR_NAMESERVICE_MSG, "Nameservice" },
87 { OLSR_HELLO_LQ_MSG, "Hello-LQ" },
88 { OLSR_TC_LQ_MSG, "TC-LQ" },
89 { 0, NULL}
90 };
91
92 struct olsr_msg4 {
93 nd_uint8_t msg_type;
94 nd_uint8_t vtime;
95 nd_uint16_t msg_len;
96 nd_ipv4 originator;
97 nd_uint8_t ttl;
98 nd_uint8_t hopcount;
99 nd_uint16_t msg_seq;
100 };
101
102 struct olsr_msg6 {
103 nd_uint8_t msg_type;
104 nd_uint8_t vtime;
105 nd_uint16_t msg_len;
106 nd_ipv6 originator;
107 nd_uint8_t ttl;
108 nd_uint8_t hopcount;
109 nd_uint16_t msg_seq;
110 };
111
112 struct olsr_hello {
113 nd_byte res[2];
114 nd_uint8_t htime;
115 nd_uint8_t will;
116 };
117
118 struct olsr_hello_link {
119 nd_uint8_t link_code;
120 nd_byte res;
121 nd_uint16_t len;
122 };
123
124 struct olsr_tc {
125 nd_uint16_t ans_seq;
126 nd_byte res[2];
127 };
128
129 struct olsr_hna4 {
130 nd_ipv4 network;
131 nd_ipv4 mask;
132 };
133
134 struct olsr_hna6 {
135 nd_ipv6 network;
136 nd_ipv6 mask;
137 };
138
139
140 /** gateway HNA flags */
141 enum gateway_hna_flags {
142 GW_HNA_FLAG_LINKSPEED = 1 << 0,
143 GW_HNA_FLAG_IPV4 = 1 << 1,
144 GW_HNA_FLAG_IPV4_NAT = 1 << 2,
145 GW_HNA_FLAG_IPV6 = 1 << 3,
146 GW_HNA_FLAG_IPV6PREFIX = 1 << 4
147 };
148
149 /** gateway HNA field byte offsets in the netmask field of the HNA */
150 enum gateway_hna_fields {
151 GW_HNA_PAD = 0,
152 GW_HNA_FLAGS = 1,
153 GW_HNA_UPLINK = 2,
154 GW_HNA_DOWNLINK = 3,
155 GW_HNA_V6PREFIXLEN = 4,
156 GW_HNA_V6PREFIX = 5
157 };
158
159
160 #define OLSR_EXTRACT_LINK_TYPE(link_code) (link_code & 0x3)
161 #define OLSR_EXTRACT_NEIGHBOR_TYPE(link_code) (link_code >> 2)
162
163 static const struct tok olsr_link_type_values[] = {
164 { 0, "Unspecified" },
165 { 1, "Asymmetric" },
166 { 2, "Symmetric" },
167 { 3, "Lost" },
168 { 0, NULL}
169 };
170
171 static const struct tok olsr_neighbor_type_values[] = {
172 { 0, "Not-Neighbor" },
173 { 1, "Symmetric" },
174 { 2, "Symmetric-MPR" },
175 { 0, NULL}
176 };
177
178 struct olsr_lq_neighbor4 {
179 nd_ipv4 neighbor;
180 nd_uint8_t link_quality;
181 nd_uint8_t neighbor_link_quality;
182 nd_byte res[2];
183 };
184
185 struct olsr_lq_neighbor6 {
186 nd_ipv6 neighbor;
187 nd_uint8_t link_quality;
188 nd_uint8_t neighbor_link_quality;
189 nd_byte res[2];
190 };
191
192 #define MAX_SMARTGW_SPEED 320000000
193
194 /**
195 * Convert an encoded 1 byte transport value (5 bits mantissa, 3 bits exponent)
196 * to an uplink/downlink speed value
197 *
198 * @param value the encoded 1 byte transport value
199 * @return the uplink/downlink speed value (in kbit/s)
200 */
201 static uint32_t deserialize_gw_speed(uint8_t value) {
202 uint32_t speed;
203 uint32_t exp;
204
205 if (!value) {
206 return 0;
207 }
208
209 if (value == UINT8_MAX) {
210 /* maximum value: also return maximum value */
211 return MAX_SMARTGW_SPEED;
212 }
213
214 speed = (value >> 3) + 1;
215 exp = value & 7;
216
217 while (exp != 0) {
218 speed *= 10;
219 exp--;
220 }
221 return speed;
222 }
223
224 /*
225 * macro to convert the 8-bit mantissa/exponent to a double float
226 * taken from olsr.org.
227 */
228 #define VTIME_SCALE_FACTOR 0.0625
229 #define ME_TO_DOUBLE(me) \
230 (double)(VTIME_SCALE_FACTOR*(1+(double)(me>>4)/16)*(double)(1<<(me&0x0F)))
231
232 /*
233 * print a neighbor list with LQ extensions.
234 */
235 static void
236 olsr_print_lq_neighbor4(netdissect_options *ndo,
237 const u_char *msg_data, u_int hello_len)
238 {
239 const struct olsr_lq_neighbor4 *lq_neighbor;
240
241 while (hello_len >= sizeof(struct olsr_lq_neighbor4)) {
242
243 lq_neighbor = (const struct olsr_lq_neighbor4 *)msg_data;
244 ND_TCHECK_SIZE(lq_neighbor);
245
246 ND_PRINT("\n\t neighbor %s, link-quality %.2f%%"
247 ", neighbor-link-quality %.2f%%",
248 GET_IPADDR_STRING(lq_neighbor->neighbor),
249 ((double) GET_U_1(lq_neighbor->link_quality)/2.55),
250 ((double) GET_U_1(lq_neighbor->neighbor_link_quality)/2.55));
251
252 msg_data += sizeof(struct olsr_lq_neighbor4);
253 hello_len -= sizeof(struct olsr_lq_neighbor4);
254 }
255 }
256
257 static void
258 olsr_print_lq_neighbor6(netdissect_options *ndo,
259 const u_char *msg_data, u_int hello_len)
260 {
261 const struct olsr_lq_neighbor6 *lq_neighbor;
262
263 while (hello_len >= sizeof(struct olsr_lq_neighbor6)) {
264
265 lq_neighbor = (const struct olsr_lq_neighbor6 *)msg_data;
266 ND_TCHECK_SIZE(lq_neighbor);
267
268 ND_PRINT("\n\t neighbor %s, link-quality %.2f%%"
269 ", neighbor-link-quality %.2f%%",
270 GET_IP6ADDR_STRING(lq_neighbor->neighbor),
271 ((double) GET_U_1(lq_neighbor->link_quality)/2.55),
272 ((double) GET_U_1(lq_neighbor->neighbor_link_quality)/2.55));
273
274 msg_data += sizeof(struct olsr_lq_neighbor6);
275 hello_len -= sizeof(struct olsr_lq_neighbor6);
276 }
277 }
278
279 /*
280 * print a neighbor list.
281 */
282 static void
283 olsr_print_neighbor(netdissect_options *ndo,
284 const u_char *msg_data, u_int hello_len)
285 {
286 int neighbor;
287
288 ND_PRINT("\n\t neighbor\n\t\t");
289 neighbor = 1;
290
291 while (hello_len >= sizeof(nd_ipv4)) {
292 /* print 4 neighbors per line */
293 ND_PRINT("%s%s", GET_IPADDR_STRING(msg_data),
294 neighbor % 4 == 0 ? "\n\t\t" : " ");
295
296 msg_data += sizeof(nd_ipv4);
297 hello_len -= sizeof(nd_ipv4);
298 }
299 }
300
301
302 void
303 olsr_print(netdissect_options *ndo,
304 const u_char *pptr, u_int length, int is_ipv6)
305 {
306 union {
307 const struct olsr_common *common;
308 const struct olsr_msg4 *msg4;
309 const struct olsr_msg6 *msg6;
310 const struct olsr_hello *hello;
311 const struct olsr_hello_link *hello_link;
312 const struct olsr_tc *tc;
313 const struct olsr_hna4 *hna;
314 } ptr;
315
316 u_int msg_type, msg_len, msg_tlen, hello_len;
317 uint16_t name_entry_type, name_entry_len;
318 u_int name_entry_padding;
319 uint8_t link_type, neighbor_type;
320 const u_char *tptr, *msg_data;
321
322 ndo->ndo_protocol = "olsr";
323 tptr = pptr;
324
325 nd_print_protocol_caps(ndo);
326 ND_PRINT("v%u", (is_ipv6) ? 6 : 4);
327
328 if (length < sizeof(struct olsr_common)) {
329 ND_PRINT(" (packet length < %zu)", sizeof(struct olsr_common));
330 goto invalid;
331 }
332
333 ptr.common = (const struct olsr_common *)tptr;
334 length = ND_MIN(length, GET_BE_U_2(ptr.common->packet_len));
335
336 ND_PRINT(", seq 0x%04x, length %u",
337 GET_BE_U_2(ptr.common->packet_seq),
338 length);
339
340 tptr += sizeof(struct olsr_common);
341
342 /*
343 * In non-verbose mode, just print version.
344 */
345 if (ndo->ndo_vflag < 1) {
346 return;
347 }
348
349 while (tptr < (pptr+length)) {
350 union
351 {
352 const struct olsr_msg4 *v4;
353 const struct olsr_msg6 *v6;
354 } msgptr;
355 int msg_len_valid = 0;
356
357 if (is_ipv6)
358 {
359 ND_TCHECK_LEN(tptr, sizeof(struct olsr_msg6));
360 msgptr.v6 = (const struct olsr_msg6 *) tptr;
361 msg_type = GET_U_1(msgptr.v6->msg_type);
362 msg_len = GET_BE_U_2(msgptr.v6->msg_len);
363 if ((msg_len >= sizeof (struct olsr_msg6))
364 && (msg_len <= length))
365 msg_len_valid = 1;
366
367 /* infinite loop check */
368 if (msg_type == 0 || msg_len == 0) {
369 return;
370 }
371
372 ND_PRINT("\n\t%s Message (%#04x), originator %s, ttl %u, hop %u"
373 "\n\t vtime %.3fs, msg-seq 0x%04x, length %u%s",
374 tok2str(olsr_msg_values, "Unknown", msg_type),
375 msg_type, GET_IP6ADDR_STRING(msgptr.v6->originator),
376 GET_U_1(msgptr.v6->ttl),
377 GET_U_1(msgptr.v6->hopcount),
378 ME_TO_DOUBLE(GET_U_1(msgptr.v6->vtime)),
379 GET_BE_U_2(msgptr.v6->msg_seq),
380 msg_len, (msg_len_valid == 0) ? " (invalid)" : "");
381 if (!msg_len_valid) {
382 return;
383 }
384
385 msg_tlen = msg_len - sizeof(struct olsr_msg6);
386 msg_data = tptr + sizeof(struct olsr_msg6);
387 }
388 else /* (!is_ipv6) */
389 {
390 ND_TCHECK_LEN(tptr, sizeof(struct olsr_msg4));
391 msgptr.v4 = (const struct olsr_msg4 *) tptr;
392 msg_type = GET_U_1(msgptr.v4->msg_type);
393 msg_len = GET_BE_U_2(msgptr.v4->msg_len);
394 if ((msg_len >= sizeof (struct olsr_msg4))
395 && (msg_len <= length))
396 msg_len_valid = 1;
397
398 /* infinite loop check */
399 if (msg_type == 0 || msg_len == 0) {
400 return;
401 }
402
403 ND_PRINT("\n\t%s Message (%#04x), originator %s, ttl %u, hop %u"
404 "\n\t vtime %.3fs, msg-seq 0x%04x, length %u%s",
405 tok2str(olsr_msg_values, "Unknown", msg_type),
406 msg_type, GET_IPADDR_STRING(msgptr.v4->originator),
407 GET_U_1(msgptr.v4->ttl),
408 GET_U_1(msgptr.v4->hopcount),
409 ME_TO_DOUBLE(GET_U_1(msgptr.v4->vtime)),
410 GET_BE_U_2(msgptr.v4->msg_seq),
411 msg_len, (msg_len_valid == 0) ? " (invalid)" : "");
412 if (!msg_len_valid) {
413 return;
414 }
415
416 msg_tlen = msg_len - sizeof(struct olsr_msg4);
417 msg_data = tptr + sizeof(struct olsr_msg4);
418 }
419
420 switch (msg_type) {
421 case OLSR_HELLO_MSG:
422 case OLSR_HELLO_LQ_MSG:
423 if (msg_tlen < sizeof(struct olsr_hello)) {
424 ND_PRINT(" (message length < %zu)", sizeof(struct olsr_hello));
425 goto invalid;
426 }
427
428 ptr.hello = (const struct olsr_hello *)msg_data;
429 ND_PRINT("\n\t hello-time %.3fs, MPR willingness %u",
430 ME_TO_DOUBLE(GET_U_1(ptr.hello->htime)),
431 GET_U_1(ptr.hello->will));
432 msg_data += sizeof(struct olsr_hello);
433 msg_tlen -= sizeof(struct olsr_hello);
434
435 while (msg_tlen >= sizeof(struct olsr_hello_link)) {
436 int hello_len_valid = 0;
437
438 /*
439 * link-type.
440 */
441 ND_TCHECK_LEN(msg_data, sizeof(struct olsr_hello_link));
442
443 ptr.hello_link = (const struct olsr_hello_link *)msg_data;
444
445 hello_len = GET_BE_U_2(ptr.hello_link->len);
446 link_type = OLSR_EXTRACT_LINK_TYPE(GET_U_1(ptr.hello_link->link_code));
447 neighbor_type = OLSR_EXTRACT_NEIGHBOR_TYPE(GET_U_1(ptr.hello_link->link_code));
448
449 if ((hello_len <= msg_tlen)
450 && (hello_len >= sizeof(struct olsr_hello_link)))
451 hello_len_valid = 1;
452
453 ND_PRINT("\n\t link-type %s, neighbor-type %s, len %u%s",
454 tok2str(olsr_link_type_values, "Unknown", link_type),
455 tok2str(olsr_neighbor_type_values, "Unknown", neighbor_type),
456 hello_len,
457 (hello_len_valid == 0) ? " (invalid)" : "");
458
459 if (hello_len_valid == 0)
460 break;
461
462 msg_data += sizeof(struct olsr_hello_link);
463 msg_tlen -= sizeof(struct olsr_hello_link);
464 hello_len -= sizeof(struct olsr_hello_link);
465
466 ND_TCHECK_LEN(msg_data, hello_len);
467 if (msg_type == OLSR_HELLO_MSG) {
468 olsr_print_neighbor(ndo, msg_data, hello_len);
469 } else {
470 if (is_ipv6) {
471 olsr_print_lq_neighbor6(ndo, msg_data, hello_len);
472 } else {
473 olsr_print_lq_neighbor4(ndo, msg_data, hello_len);
474 }
475 }
476
477 msg_data += hello_len;
478 msg_tlen -= hello_len;
479 }
480 break;
481
482 case OLSR_TC_MSG:
483 case OLSR_TC_LQ_MSG:
484 if (msg_tlen < sizeof(struct olsr_tc)) {
485 ND_PRINT(" (message length < %zu)", sizeof(struct olsr_tc));
486 goto invalid;
487 }
488 ND_TCHECK_LEN(msg_data, sizeof(struct olsr_tc));
489
490 ptr.tc = (const struct olsr_tc *)msg_data;
491 ND_PRINT("\n\t advertised neighbor seq 0x%04x",
492 GET_BE_U_2(ptr.tc->ans_seq));
493 msg_data += sizeof(struct olsr_tc);
494 msg_tlen -= sizeof(struct olsr_tc);
495
496 if (msg_type == OLSR_TC_MSG) {
497 olsr_print_neighbor(ndo, msg_data, msg_tlen);
498 } else {
499 if (is_ipv6) {
500 olsr_print_lq_neighbor6(ndo, msg_data, msg_tlen);
501 } else {
502 olsr_print_lq_neighbor4(ndo, msg_data, msg_tlen);
503 }
504 }
505 break;
506
507 case OLSR_MID_MSG:
508 {
509 u_int addr_size = (u_int)sizeof(nd_ipv4);
510
511 if (is_ipv6)
512 addr_size = (u_int)sizeof(nd_ipv6);
513
514 while (msg_tlen >= addr_size) {
515 ND_TCHECK_LEN(msg_data, addr_size);
516 ND_PRINT("\n\t interface address %s",
517 is_ipv6 ? GET_IP6ADDR_STRING(msg_data) :
518 GET_IPADDR_STRING(msg_data));
519
520 msg_data += addr_size;
521 msg_tlen -= addr_size;
522 }
523 break;
524 }
525
526 case OLSR_HNA_MSG:
527 if (is_ipv6)
528 {
529 int i = 0;
530
531 ND_PRINT("\n\t Advertised networks (total %u)",
532 (unsigned int) (msg_tlen / sizeof(struct olsr_hna6)));
533
534 while (msg_tlen >= sizeof(struct olsr_hna6)) {
535 const struct olsr_hna6 *hna6;
536
537 ND_TCHECK_LEN(msg_data, sizeof(struct olsr_hna6));
538
539 hna6 = (const struct olsr_hna6 *)msg_data;
540
541 ND_PRINT("\n\t #%i: %s/%u",
542 i, GET_IP6ADDR_STRING(hna6->network),
543 mask62plen (hna6->mask));
544
545 msg_data += sizeof(struct olsr_hna6);
546 msg_tlen -= sizeof(struct olsr_hna6);
547 }
548 }
549 else
550 {
551 int col = 0;
552
553 ND_PRINT("\n\t Advertised networks (total %u)",
554 (unsigned int) (msg_tlen / sizeof(struct olsr_hna4)));
555
556 while (msg_tlen >= sizeof(struct olsr_hna4)) {
557 ND_TCHECK_LEN(msg_data, sizeof(struct olsr_hna4));
558
559 ptr.hna = (const struct olsr_hna4 *)msg_data;
560
561 /* print 4 prefixes per line */
562 if (!ptr.hna->network[0] && !ptr.hna->network[1] &&
563 !ptr.hna->network[2] && !ptr.hna->network[3] &&
564 !ptr.hna->mask[GW_HNA_PAD] &&
565 ptr.hna->mask[GW_HNA_FLAGS]) {
566 /* smart gateway */
567 ND_PRINT("%sSmart-Gateway:%s%s%s%s%s %u/%u",
568 col == 0 ? "\n\t " : ", ", /* indent */
569 /* sgw */
570 /* LINKSPEED */
571 (ptr.hna->mask[GW_HNA_FLAGS] &
572 GW_HNA_FLAG_LINKSPEED) ? " LINKSPEED" : "",
573 /* IPV4 */
574 (ptr.hna->mask[GW_HNA_FLAGS] &
575 GW_HNA_FLAG_IPV4) ? " IPV4" : "",
576 /* IPV4-NAT */
577 (ptr.hna->mask[GW_HNA_FLAGS] &
578 GW_HNA_FLAG_IPV4_NAT) ? " IPV4-NAT" : "",
579 /* IPV6 */
580 (ptr.hna->mask[GW_HNA_FLAGS] &
581 GW_HNA_FLAG_IPV6) ? " IPV6" : "",
582 /* IPv6PREFIX */
583 (ptr.hna->mask[GW_HNA_FLAGS] &
584 GW_HNA_FLAG_IPV6PREFIX) ? " IPv6-PREFIX" : "",
585 /* uplink */
586 (ptr.hna->mask[GW_HNA_FLAGS] &
587 GW_HNA_FLAG_LINKSPEED) ?
588 deserialize_gw_speed(ptr.hna->mask[GW_HNA_UPLINK]) : 0,
589 /* downlink */
590 (ptr.hna->mask[GW_HNA_FLAGS] &
591 GW_HNA_FLAG_LINKSPEED) ?
592 deserialize_gw_speed(ptr.hna->mask[GW_HNA_DOWNLINK]) : 0
593 );
594 } else {
595 /* normal route */
596 ND_PRINT("%s%s/%u",
597 col == 0 ? "\n\t " : ", ",
598 GET_IPADDR_STRING(ptr.hna->network),
599 mask2plen(GET_BE_U_4(ptr.hna->mask)));
600 }
601
602 msg_data += sizeof(struct olsr_hna4);
603 msg_tlen -= sizeof(struct olsr_hna4);
604
605 col = (col + 1) % 4;
606 }
607 }
608 break;
609
610 case OLSR_NAMESERVICE_MSG:
611 {
612 u_int name_entries;
613 u_int addr_size;
614 int name_entries_valid;
615 u_int i;
616
617 if (msg_tlen < 4) {
618 ND_PRINT(" (message length < 4)");
619 goto invalid;
620 }
621
622 name_entries = GET_BE_U_2(msg_data + 2);
623 addr_size = 4;
624 if (is_ipv6)
625 addr_size = 16;
626
627 name_entries_valid = 0;
628 if ((name_entries > 0)
629 && ((name_entries * (4 + addr_size)) <= msg_tlen))
630 name_entries_valid = 1;
631
632 ND_PRINT("\n\t Version %u, Entries %u%s",
633 GET_BE_U_2(msg_data),
634 name_entries, (name_entries_valid == 0) ? " (invalid)" : "");
635
636 if (name_entries_valid == 0)
637 break;
638
639 msg_data += 4;
640 msg_tlen -= 4;
641
642 for (i = 0; i < name_entries; i++) {
643 int name_entry_len_valid = 0;
644
645 if (msg_tlen < 4)
646 break;
647
648 name_entry_type = GET_BE_U_2(msg_data);
649 name_entry_len = GET_BE_U_2(msg_data + 2);
650
651 msg_data += 4;
652 msg_tlen -= 4;
653
654 if ((name_entry_len > 0) && ((addr_size + name_entry_len) <= msg_tlen))
655 name_entry_len_valid = 1;
656
657 ND_PRINT("\n\t #%u: type %#06x, length %u%s",
658 (unsigned int) i, name_entry_type,
659 name_entry_len, (name_entry_len_valid == 0) ? " (invalid)" : "");
660
661 if (name_entry_len_valid == 0)
662 break;
663
664 /* 32-bit alignment */
665 name_entry_padding = 0;
666 if (name_entry_len%4 != 0)
667 name_entry_padding = 4-(name_entry_len%4);
668
669 if (msg_tlen < addr_size + name_entry_len + name_entry_padding) {
670 ND_PRINT(" (oversized name entry)");
671 goto invalid;
672 }
673
674 ND_TCHECK_LEN(msg_data,
675 addr_size + name_entry_len + name_entry_padding);
676
677 if (is_ipv6)
678 ND_PRINT(", address %s, name \"",
679 GET_IP6ADDR_STRING(msg_data));
680 else
681 ND_PRINT(", address %s, name \"",
682 GET_IPADDR_STRING(msg_data));
683 nd_printjn(ndo, msg_data + addr_size, name_entry_len);
684 ND_PRINT("\"");
685
686 msg_data += addr_size + name_entry_len + name_entry_padding;
687 msg_tlen -= addr_size + name_entry_len + name_entry_padding;
688 } /* for (i = 0; i < name_entries; i++) */
689 break;
690 } /* case OLSR_NAMESERVICE_MSG */
691
692 /*
693 * FIXME those are the defined messages that lack a decoder
694 * you are welcome to contribute code ;-)
695 */
696 case OLSR_POWERINFO_MSG:
697 default:
698 print_unknown_data(ndo, msg_data, "\n\t ", msg_tlen);
699 break;
700 } /* switch (msg_type) */
701 tptr += msg_len;
702 } /* while (tptr < (pptr+length)) */
703
704 return;
705
706 invalid:
707 nd_print_invalid(ndo);
708 }
[mirror] the TCPdump network dissector