]> The Tcpdump Group git mirrors - tcpdump/blob - print-lwres.c
projects / tcpdump / blob


f252275fc34ec8d54fbdcb7fbabbae3e3b11029e
[tcpdump] / print-lwres.c
1 /*
2 * Copyright (C) 2001 WIDE Project.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the project nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30 /* \summary: BIND9 Lightweight Resolver protocol printer */
31
32 #ifdef HAVE_CONFIG_H
33 #include <config.h>
34 #endif
35
36 #include "netdissect-stdinc.h"
37
38 #define ND_LONGJMP_FROM_TCHECK
39 #include "netdissect.h"
40 #include "addrtoname.h"
41 #include "extract.h"
42
43 #include "nameser.h"
44
45 /* BIND9 lib/lwres/include/lwres */
46 /*
47 * Use nd_uint16_t for lwres_uint16_t
48 * Use nd_uint32_t for lwres_uint32_t
49 */
50
51 struct lwres_lwpacket {
52 nd_uint32_t length;
53 nd_uint16_t version;
54 nd_uint16_t pktflags;
55 nd_uint32_t serial;
56 nd_uint32_t opcode;
57 nd_uint32_t result;
58 nd_uint32_t recvlength;
59 nd_uint16_t authtype;
60 nd_uint16_t authlength;
61 };
62
63 #define LWRES_LWPACKETFLAG_RESPONSE 0x0001U /* if set, pkt is a response */
64
65 #define LWRES_LWPACKETVERSION_0 0
66
67 #define LWRES_FLAG_TRUSTNOTREQUIRED 0x00000001U
68 #define LWRES_FLAG_SECUREDATA 0x00000002U
69
70 /*
71 * no-op
72 */
73 #define LWRES_OPCODE_NOOP 0x00000000U
74
75 typedef struct {
76 /* public */
77 nd_uint16_t datalength;
78 /* data follows */
79 } lwres_nooprequest_t;
80
81 typedef struct {
82 /* public */
83 nd_uint16_t datalength;
84 /* data follows */
85 } lwres_noopresponse_t;
86
87 /*
88 * get addresses by name
89 */
90 #define LWRES_OPCODE_GETADDRSBYNAME 0x00010001U
91
92 typedef struct lwres_addr lwres_addr_t;
93
94 struct lwres_addr {
95 nd_uint32_t family;
96 nd_uint16_t length;
97 /* address follows */
98 };
99 #define LWRES_ADDR_LEN 6
100
101 typedef struct {
102 /* public */
103 nd_uint32_t flags;
104 nd_uint32_t addrtypes;
105 nd_uint16_t namelen;
106 /* name follows */
107 } lwres_gabnrequest_t;
108 #define LWRES_GABNREQUEST_LEN 10
109
110 typedef struct {
111 /* public */
112 nd_uint32_t flags;
113 nd_uint16_t naliases;
114 nd_uint16_t naddrs;
115 nd_uint16_t realnamelen;
116 /* aliases follows */
117 /* addrs follows */
118 /* realname follows */
119 } lwres_gabnresponse_t;
120 #define LWRES_GABNRESPONSE_LEN 10
121
122 /*
123 * get name by address
124 */
125 #define LWRES_OPCODE_GETNAMEBYADDR 0x00010002U
126 typedef struct {
127 /* public */
128 nd_uint32_t flags;
129 /* addr follows */
130 } lwres_gnbarequest_t;
131 #define LWRES_GNBAREQUEST_LEN 4
132
133 typedef struct {
134 /* public */
135 nd_uint32_t flags;
136 nd_uint16_t naliases;
137 nd_uint16_t realnamelen;
138 /* aliases follows */
139 /* realname follows */
140 } lwres_gnbaresponse_t;
141 #define LWRES_GNBARESPONSE_LEN 8
142
143 /*
144 * get rdata by name
145 */
146 #define LWRES_OPCODE_GETRDATABYNAME 0x00010003U
147
148 typedef struct {
149 /* public */
150 nd_uint32_t flags;
151 nd_uint16_t rdclass;
152 nd_uint16_t rdtype;
153 nd_uint16_t namelen;
154 /* name follows */
155 } lwres_grbnrequest_t;
156 #define LWRES_GRBNREQUEST_LEN 10
157
158 typedef struct {
159 /* public */
160 nd_uint32_t flags;
161 nd_uint16_t rdclass;
162 nd_uint16_t rdtype;
163 nd_uint32_t ttl;
164 nd_uint16_t nrdatas;
165 nd_uint16_t nsigs;
166 /* realname here (len + name) */
167 /* rdata here (len + name) */
168 /* signatures here (len + name) */
169 } lwres_grbnresponse_t;
170 #define LWRES_GRBNRESPONSE_LEN 16
171
172 #define LWRDATA_VALIDATED 0x00000001
173
174 #define LWRES_ADDRTYPE_V4 0x00000001U /* ipv4 */
175 #define LWRES_ADDRTYPE_V6 0x00000002U /* ipv6 */
176
177 #define LWRES_MAX_ALIASES 16 /* max # of aliases */
178 #define LWRES_MAX_ADDRS 64 /* max # of addrs */
179
180 static const struct tok opcode[] = {
181 { LWRES_OPCODE_NOOP, "noop", },
182 { LWRES_OPCODE_GETADDRSBYNAME, "getaddrsbyname", },
183 { LWRES_OPCODE_GETNAMEBYADDR, "getnamebyaddr", },
184 { LWRES_OPCODE_GETRDATABYNAME, "getrdatabyname", },
185 { 0, NULL, },
186 };
187
188 /* print-domain.c */
189 extern const struct tok ns_type2str[];
190 extern const struct tok ns_class2str[];
191
192 static unsigned
193 lwres_printname(netdissect_options *ndo,
194 u_int l, const u_char *p0)
195 {
196 ND_PRINT(" ");
197 nd_printjn(ndo, p0, l);
198 p0 += l;
199 if (GET_U_1(p0))
200 ND_PRINT(" (not NUL-terminated!)");
201 return l + 1;
202 }
203
204 static unsigned
205 lwres_printnamelen(netdissect_options *ndo,
206 const u_char *p)
207 {
208 uint16_t l;
209 int advance;
210
211 l = GET_BE_U_2(p);
212 advance = lwres_printname(ndo, l, p + 2);
213 return 2 + advance;
214 }
215
216 static unsigned
217 lwres_printbinlen(netdissect_options *ndo,
218 const u_char *p0)
219 {
220 const u_char *p;
221 uint16_t l;
222 int i;
223
224 p = p0;
225 l = GET_BE_U_2(p);
226 p += 2;
227 for (i = 0; i < l; i++) {
228 ND_PRINT("%02x", GET_U_1(p));
229 p++;
230 }
231 return 2 + l;
232 }
233
234 static int
235 lwres_printaddr(netdissect_options *ndo,
236 const u_char *p0)
237 {
238 const u_char *p;
239 const lwres_addr_t *ap;
240 uint16_t l;
241 int i;
242
243 p = p0;
244 ap = (const lwres_addr_t *)p;
245 l = GET_BE_U_2(ap->length);
246 p += LWRES_ADDR_LEN;
247 ND_TCHECK_LEN(p, l);
248
249 switch (GET_BE_U_4(ap->family)) {
250 case 1: /* IPv4 */
251 if (l < 4)
252 return -1;
253 ND_PRINT(" %s", GET_IPADDR_STRING(p));
254 p += sizeof(nd_ipv4);
255 break;
256 case 2: /* IPv6 */
257 if (l < 16)
258 return -1;
259 ND_PRINT(" %s", GET_IP6ADDR_STRING(p));
260 p += sizeof(nd_ipv6);
261 break;
262 default:
263 ND_PRINT(" %u/", GET_BE_U_4(ap->family));
264 for (i = 0; i < l; i++) {
265 ND_PRINT("%02x", GET_U_1(p));
266 p++;
267 }
268 }
269
270 return ND_BYTES_BETWEEN(p0, p);
271 }
272
273 void
274 lwres_print(netdissect_options *ndo,
275 const u_char *bp, u_int length)
276 {
277 const u_char *p;
278 const struct lwres_lwpacket *np;
279 uint32_t v;
280 const u_char *s;
281 int response;
282 int advance;
283 int unsupported = 0;
284
285 ndo->ndo_protocol = "lwres";
286 np = (const struct lwres_lwpacket *)bp;
287 ND_TCHECK_2(np->authlength);
288
289 ND_PRINT(" lwres");
290 v = GET_BE_U_2(np->version);
291 if (ndo->ndo_vflag || v != LWRES_LWPACKETVERSION_0)
292 ND_PRINT(" v%u", v);
293 if (v != LWRES_LWPACKETVERSION_0) {
294 uint32_t pkt_len = GET_BE_U_4(np->length);
295 ND_TCHECK_LEN(bp, pkt_len);
296 s = bp + pkt_len;
297 goto tail;
298 }
299
300 response = GET_BE_U_2(np->pktflags) & LWRES_LWPACKETFLAG_RESPONSE;
301
302 /* opcode and pktflags */
303 v = GET_BE_U_4(np->opcode);
304 ND_PRINT(" %s%s", tok2str(opcode, "#0x%x", v), response ? "" : "?");
305
306 /* pktflags */
307 v = GET_BE_U_2(np->pktflags);
308 if (v & ~LWRES_LWPACKETFLAG_RESPONSE)
309 ND_PRINT("[0x%x]", v);
310
311 if (ndo->ndo_vflag > 1) {
312 ND_PRINT(" ("); /*)*/
313 ND_PRINT("serial:0x%x", GET_BE_U_4(np->serial));
314 ND_PRINT(" result:0x%x", GET_BE_U_4(np->result));
315 ND_PRINT(" recvlen:%u", GET_BE_U_4(np->recvlength));
316 /* BIND910: not used */
317 if (ndo->ndo_vflag > 2) {
318 ND_PRINT(" authtype:0x%x", GET_BE_U_2(np->authtype));
319 ND_PRINT(" authlen:%u", GET_BE_U_2(np->authlength));
320 }
321 /*(*/
322 ND_PRINT(")");
323 }
324
325 /* per-opcode content */
326 if (!response) {
327 /*
328 * queries
329 */
330 const lwres_gabnrequest_t *gabn;
331 const lwres_gnbarequest_t *gnba;
332 const lwres_grbnrequest_t *grbn;
333 uint32_t l;
334
335 gabn = NULL;
336 gnba = NULL;
337 grbn = NULL;
338
339 p = (const u_char *)(np + 1);
340 switch (GET_BE_U_4(np->opcode)) {
341 case LWRES_OPCODE_NOOP:
342 s = p;
343 break;
344 case LWRES_OPCODE_GETADDRSBYNAME:
345 gabn = (const lwres_gabnrequest_t *)p;
346 ND_TCHECK_2(gabn->namelen);
347
348 /* BIND910: not used */
349 if (ndo->ndo_vflag > 2) {
350 ND_PRINT(" flags:0x%x",
351 GET_BE_U_4(gabn->flags));
352 }
353
354 v = GET_BE_U_4(gabn->addrtypes);
355 switch (v & (LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6)) {
356 case LWRES_ADDRTYPE_V4:
357 ND_PRINT(" IPv4");
358 break;
359 case LWRES_ADDRTYPE_V6:
360 ND_PRINT(" IPv6");
361 break;
362 case LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6:
363 ND_PRINT(" IPv4/6");
364 break;
365 }
366 if (v & ~(LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6))
367 ND_PRINT("[0x%x]", v);
368
369 s = p + LWRES_GABNREQUEST_LEN;
370 l = GET_BE_U_2(gabn->namelen);
371 advance = lwres_printname(ndo, l, s);
372 s += advance;
373 break;
374 case LWRES_OPCODE_GETNAMEBYADDR:
375 gnba = (const lwres_gnbarequest_t *)p;
376 ND_TCHECK_4(gnba->flags);
377
378 /* BIND910: not used */
379 if (ndo->ndo_vflag > 2) {
380 ND_PRINT(" flags:0x%x",
381 GET_BE_U_4(gnba->flags));
382 }
383
384 s = p + LWRES_GNBAREQUEST_LEN;
385 advance = lwres_printaddr(ndo, s);
386 if (advance < 0)
387 goto invalid;
388 s += advance;
389 break;
390 case LWRES_OPCODE_GETRDATABYNAME:
391 /* XXX no trace, not tested */
392 grbn = (const lwres_grbnrequest_t *)p;
393 ND_TCHECK_2(grbn->namelen);
394
395 /* BIND910: not used */
396 if (ndo->ndo_vflag > 2) {
397 ND_PRINT(" flags:0x%x",
398 GET_BE_U_4(grbn->flags));
399 }
400
401 ND_PRINT(" %s", tok2str(ns_type2str, "Type%u",
402 GET_BE_U_2(grbn->rdtype)));
403 if (GET_BE_U_2(grbn->rdclass) != C_IN) {
404 ND_PRINT(" %s", tok2str(ns_class2str, "Class%u",
405 GET_BE_U_2(grbn->rdclass)));
406 }
407
408 s = p + LWRES_GRBNREQUEST_LEN;
409 l = GET_BE_U_2(grbn->namelen);
410 advance = lwres_printname(ndo, l, s);
411 s += advance;
412 break;
413 default:
414 s = p;
415 unsupported++;
416 break;
417 }
418 } else {
419 /*
420 * responses
421 */
422 const lwres_gabnresponse_t *gabn;
423 const lwres_gnbaresponse_t *gnba;
424 const lwres_grbnresponse_t *grbn;
425 uint32_t l, na;
426 uint32_t i;
427
428 gabn = NULL;
429 gnba = NULL;
430 grbn = NULL;
431
432 p = (const u_char *)(np + 1);
433 switch (GET_BE_U_4(np->opcode)) {
434 case LWRES_OPCODE_NOOP:
435 s = p;
436 break;
437 case LWRES_OPCODE_GETADDRSBYNAME:
438 gabn = (const lwres_gabnresponse_t *)p;
439 ND_TCHECK_2(gabn->realnamelen);
440
441 /* BIND910: not used */
442 if (ndo->ndo_vflag > 2) {
443 ND_PRINT(" flags:0x%x",
444 GET_BE_U_4(gabn->flags));
445 }
446
447 ND_PRINT(" %u/%u", GET_BE_U_2(gabn->naliases),
448 GET_BE_U_2(gabn->naddrs));
449
450 s = p + LWRES_GABNRESPONSE_LEN;
451 l = GET_BE_U_2(gabn->realnamelen);
452 advance = lwres_printname(ndo, l, s);
453 s += advance;
454
455 /* aliases */
456 na = GET_BE_U_2(gabn->naliases);
457 for (i = 0; i < na; i++) {
458 advance = lwres_printnamelen(ndo, s);
459 s += advance;
460 }
461
462 /* addrs */
463 na = GET_BE_U_2(gabn->naddrs);
464 for (i = 0; i < na; i++) {
465 advance = lwres_printaddr(ndo, s);
466 if (advance < 0)
467 goto invalid;
468 s += advance;
469 }
470 break;
471 case LWRES_OPCODE_GETNAMEBYADDR:
472 gnba = (const lwres_gnbaresponse_t *)p;
473 ND_TCHECK_2(gnba->realnamelen);
474
475 /* BIND910: not used */
476 if (ndo->ndo_vflag > 2) {
477 ND_PRINT(" flags:0x%x",
478 GET_BE_U_4(gnba->flags));
479 }
480
481 ND_PRINT(" %u", GET_BE_U_2(gnba->naliases));
482
483 s = p + LWRES_GNBARESPONSE_LEN;
484 l = GET_BE_U_2(gnba->realnamelen);
485 advance = lwres_printname(ndo, l, s);
486 s += advance;
487
488 /* aliases */
489 na = GET_BE_U_2(gnba->naliases);
490 for (i = 0; i < na; i++) {
491 advance = lwres_printnamelen(ndo, s);
492 s += advance;
493 }
494 break;
495 case LWRES_OPCODE_GETRDATABYNAME:
496 /* XXX no trace, not tested */
497 grbn = (const lwres_grbnresponse_t *)p;
498 ND_TCHECK_2(grbn->nsigs);
499
500 /* BIND910: not used */
501 if (ndo->ndo_vflag > 2) {
502 ND_PRINT(" flags:0x%x",
503 GET_BE_U_4(grbn->flags));
504 }
505
506 ND_PRINT(" %s", tok2str(ns_type2str, "Type%u",
507 GET_BE_U_2(grbn->rdtype)));
508 if (GET_BE_U_2(grbn->rdclass) != C_IN) {
509 ND_PRINT(" %s", tok2str(ns_class2str, "Class%u",
510 GET_BE_U_2(grbn->rdclass)));
511 }
512 ND_PRINT(" TTL ");
513 unsigned_relts_print(ndo,
514 GET_BE_U_4(grbn->ttl));
515 ND_PRINT(" %u/%u", GET_BE_U_2(grbn->nrdatas),
516 GET_BE_U_2(grbn->nsigs));
517
518 s = p + LWRES_GRBNRESPONSE_LEN;
519 advance = lwres_printnamelen(ndo, s);
520 s += advance;
521
522 /* rdatas */
523 na = GET_BE_U_2(grbn->nrdatas);
524 for (i = 0; i < na; i++) {
525 /* XXX should decode resource data */
526 advance = lwres_printbinlen(ndo, s);
527 s += advance;
528 }
529
530 /* sigs */
531 na = GET_BE_U_2(grbn->nsigs);
532 for (i = 0; i < na; i++) {
533 /* XXX how should we print it? */
534 advance = lwres_printbinlen(ndo, s);
535 s += advance;
536 }
537 break;
538 default:
539 s = p;
540 unsupported++;
541 break;
542 }
543 }
544
545 tail:
546 /* length mismatch */
547 if (GET_BE_U_4(np->length) != length) {
548 ND_PRINT(" [len: %u != %u]", GET_BE_U_4(np->length),
549 length);
550 }
551 if (!unsupported && ND_BYTES_BETWEEN(bp, s) < GET_BE_U_4(np->length))
552 ND_PRINT("[extra]");
553 return;
554
555 invalid:
556 nd_print_invalid(ndo);
557 }
[mirror] the TCPdump network dissector