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