xref: /dragonfly/contrib/tcpdump/print-lwres.c (revision ed775ee7)
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
lwres_printname(netdissect_options * ndo,size_t l,const u_char * p0)193 lwres_printname(netdissect_options *ndo,
194                 size_t l, const u_char *p0)
195 {
196 	ND_PRINT(" ");
197 	(void)nd_printn(ndo, p0, l, NULL);
198 	p0 += l;
199 	if (GET_U_1(p0))
200 		ND_PRINT(" (not NUL-terminated!)");
201 	return l + 1;
202 }
203 
204 static unsigned
lwres_printnamelen(netdissect_options * ndo,const u_char * p)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
lwres_printbinlen(netdissect_options * ndo,const u_char * p0)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
lwres_printaddr(netdissect_options * ndo,const u_char * p0)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(p, p0);
271 }
272 
273 void
lwres_print(netdissect_options * ndo,const u_char * bp,u_int length)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 		s = bp + GET_BE_U_4(np->length);
295 		goto tail;
296 	}
297 
298 	response = GET_BE_U_2(np->pktflags) & LWRES_LWPACKETFLAG_RESPONSE;
299 
300 	/* opcode and pktflags */
301 	v = GET_BE_U_4(np->opcode);
302 	ND_PRINT(" %s%s", tok2str(opcode, "#0x%x", v), response ? "" : "?");
303 
304 	/* pktflags */
305 	v = GET_BE_U_2(np->pktflags);
306 	if (v & ~LWRES_LWPACKETFLAG_RESPONSE)
307 		ND_PRINT("[0x%x]", v);
308 
309 	if (ndo->ndo_vflag > 1) {
310 		ND_PRINT(" (");	/*)*/
311 		ND_PRINT("serial:0x%x", GET_BE_U_4(np->serial));
312 		ND_PRINT(" result:0x%x", GET_BE_U_4(np->result));
313 		ND_PRINT(" recvlen:%u", GET_BE_U_4(np->recvlength));
314 		/* BIND910: not used */
315 		if (ndo->ndo_vflag > 2) {
316 			ND_PRINT(" authtype:0x%x", GET_BE_U_2(np->authtype));
317 			ND_PRINT(" authlen:%u", GET_BE_U_2(np->authlength));
318 		}
319 		/*(*/
320 		ND_PRINT(")");
321 	}
322 
323 	/* per-opcode content */
324 	if (!response) {
325 		/*
326 		 * queries
327 		 */
328 		const lwres_gabnrequest_t *gabn;
329 		const lwres_gnbarequest_t *gnba;
330 		const lwres_grbnrequest_t *grbn;
331 		uint32_t l;
332 
333 		gabn = NULL;
334 		gnba = NULL;
335 		grbn = NULL;
336 
337 		p = (const u_char *)(np + 1);
338 		switch (GET_BE_U_4(np->opcode)) {
339 		case LWRES_OPCODE_NOOP:
340 			s = p;
341 			break;
342 		case LWRES_OPCODE_GETADDRSBYNAME:
343 			gabn = (const lwres_gabnrequest_t *)p;
344 			ND_TCHECK_2(gabn->namelen);
345 
346 			/* BIND910: not used */
347 			if (ndo->ndo_vflag > 2) {
348 				ND_PRINT(" flags:0x%x",
349 				    GET_BE_U_4(gabn->flags));
350 			}
351 
352 			v = GET_BE_U_4(gabn->addrtypes);
353 			switch (v & (LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6)) {
354 			case LWRES_ADDRTYPE_V4:
355 				ND_PRINT(" IPv4");
356 				break;
357 			case LWRES_ADDRTYPE_V6:
358 				ND_PRINT(" IPv6");
359 				break;
360 			case LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6:
361 				ND_PRINT(" IPv4/6");
362 				break;
363 			}
364 			if (v & ~(LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6))
365 				ND_PRINT("[0x%x]", v);
366 
367 			s = p + LWRES_GABNREQUEST_LEN;
368 			l = GET_BE_U_2(gabn->namelen);
369 			advance = lwres_printname(ndo, l, s);
370 			s += advance;
371 			break;
372 		case LWRES_OPCODE_GETNAMEBYADDR:
373 			gnba = (const lwres_gnbarequest_t *)p;
374 			ND_TCHECK_4(gnba->flags);
375 
376 			/* BIND910: not used */
377 			if (ndo->ndo_vflag > 2) {
378 				ND_PRINT(" flags:0x%x",
379 				    GET_BE_U_4(gnba->flags));
380 			}
381 
382 			s = p + LWRES_GNBAREQUEST_LEN;
383 			advance = lwres_printaddr(ndo, s);
384 			if (advance < 0)
385 				goto invalid;
386 			s += advance;
387 			break;
388 		case LWRES_OPCODE_GETRDATABYNAME:
389 			/* XXX no trace, not tested */
390 			grbn = (const lwres_grbnrequest_t *)p;
391 			ND_TCHECK_2(grbn->namelen);
392 
393 			/* BIND910: not used */
394 			if (ndo->ndo_vflag > 2) {
395 				ND_PRINT(" flags:0x%x",
396 				    GET_BE_U_4(grbn->flags));
397 			}
398 
399 			ND_PRINT(" %s", tok2str(ns_type2str, "Type%u",
400 			    GET_BE_U_2(grbn->rdtype)));
401 			if (GET_BE_U_2(grbn->rdclass) != C_IN) {
402 				ND_PRINT(" %s", tok2str(ns_class2str, "Class%u",
403 				    GET_BE_U_2(grbn->rdclass)));
404 			}
405 
406 			s = p + LWRES_GRBNREQUEST_LEN;
407 			l = GET_BE_U_2(grbn->namelen);
408 			advance = lwres_printname(ndo, l, s);
409 			s += advance;
410 			break;
411 		default:
412 			s = p;
413 			unsupported++;
414 			break;
415 		}
416 	} else {
417 		/*
418 		 * responses
419 		 */
420 		const lwres_gabnresponse_t *gabn;
421 		const lwres_gnbaresponse_t *gnba;
422 		const lwres_grbnresponse_t *grbn;
423 		uint32_t l, na;
424 		uint32_t i;
425 
426 		gabn = NULL;
427 		gnba = NULL;
428 		grbn = NULL;
429 
430 		p = (const u_char *)(np + 1);
431 		switch (GET_BE_U_4(np->opcode)) {
432 		case LWRES_OPCODE_NOOP:
433 			s = p;
434 			break;
435 		case LWRES_OPCODE_GETADDRSBYNAME:
436 			gabn = (const lwres_gabnresponse_t *)p;
437 			ND_TCHECK_2(gabn->realnamelen);
438 
439 			/* BIND910: not used */
440 			if (ndo->ndo_vflag > 2) {
441 				ND_PRINT(" flags:0x%x",
442 				    GET_BE_U_4(gabn->flags));
443 			}
444 
445 			ND_PRINT(" %u/%u", GET_BE_U_2(gabn->naliases),
446 				  GET_BE_U_2(gabn->naddrs));
447 
448 			s = p + LWRES_GABNRESPONSE_LEN;
449 			l = GET_BE_U_2(gabn->realnamelen);
450 			advance = lwres_printname(ndo, l, s);
451 			s += advance;
452 
453 			/* aliases */
454 			na = GET_BE_U_2(gabn->naliases);
455 			for (i = 0; i < na; i++) {
456 				advance = lwres_printnamelen(ndo, s);
457 				s += advance;
458 			}
459 
460 			/* addrs */
461 			na = GET_BE_U_2(gabn->naddrs);
462 			for (i = 0; i < na; i++) {
463 				advance = lwres_printaddr(ndo, s);
464 				if (advance < 0)
465 					goto invalid;
466 				s += advance;
467 			}
468 			break;
469 		case LWRES_OPCODE_GETNAMEBYADDR:
470 			gnba = (const lwres_gnbaresponse_t *)p;
471 			ND_TCHECK_2(gnba->realnamelen);
472 
473 			/* BIND910: not used */
474 			if (ndo->ndo_vflag > 2) {
475 				ND_PRINT(" flags:0x%x",
476 				    GET_BE_U_4(gnba->flags));
477 			}
478 
479 			ND_PRINT(" %u", GET_BE_U_2(gnba->naliases));
480 
481 			s = p + LWRES_GNBARESPONSE_LEN;
482 			l = GET_BE_U_2(gnba->realnamelen);
483 			advance = lwres_printname(ndo, l, s);
484 			s += advance;
485 
486 			/* aliases */
487 			na = GET_BE_U_2(gnba->naliases);
488 			for (i = 0; i < na; i++) {
489 				advance = lwres_printnamelen(ndo, s);
490 				s += advance;
491 			}
492 			break;
493 		case LWRES_OPCODE_GETRDATABYNAME:
494 			/* XXX no trace, not tested */
495 			grbn = (const lwres_grbnresponse_t *)p;
496 			ND_TCHECK_2(grbn->nsigs);
497 
498 			/* BIND910: not used */
499 			if (ndo->ndo_vflag > 2) {
500 				ND_PRINT(" flags:0x%x",
501 				    GET_BE_U_4(grbn->flags));
502 			}
503 
504 			ND_PRINT(" %s", tok2str(ns_type2str, "Type%u",
505 			    GET_BE_U_2(grbn->rdtype)));
506 			if (GET_BE_U_2(grbn->rdclass) != C_IN) {
507 				ND_PRINT(" %s", tok2str(ns_class2str, "Class%u",
508 				    GET_BE_U_2(grbn->rdclass)));
509 			}
510 			ND_PRINT(" TTL ");
511 			unsigned_relts_print(ndo,
512 					     GET_BE_U_4(grbn->ttl));
513 			ND_PRINT(" %u/%u", GET_BE_U_2(grbn->nrdatas),
514 				  GET_BE_U_2(grbn->nsigs));
515 
516 			s = p + LWRES_GRBNRESPONSE_LEN;
517 			advance = lwres_printnamelen(ndo, s);
518 			s += advance;
519 
520 			/* rdatas */
521 			na = GET_BE_U_2(grbn->nrdatas);
522 			for (i = 0; i < na; i++) {
523 				/* XXX should decode resource data */
524 				advance = lwres_printbinlen(ndo, s);
525 				s += advance;
526 			}
527 
528 			/* sigs */
529 			na = GET_BE_U_2(grbn->nsigs);
530 			for (i = 0; i < na; i++) {
531 				/* XXX how should we print it? */
532 				advance = lwres_printbinlen(ndo, s);
533 				s += advance;
534 			}
535 			break;
536 		default:
537 			s = p;
538 			unsupported++;
539 			break;
540 		}
541 	}
542 
543   tail:
544 	/* length mismatch */
545 	if (GET_BE_U_4(np->length) != length) {
546 		ND_PRINT(" [len: %u != %u]", GET_BE_U_4(np->length),
547 			  length);
548 	}
549 	if (!unsupported && s < bp + GET_BE_U_4(np->length))
550 		ND_PRINT("[extra]");
551 	return;
552 
553   invalid:
554 	nd_print_invalid(ndo);
555 }
556