1/*
2 * Copyright (c) 1998-2011 The TCPDUMP project
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that: (1) source code
6 * distributions retain the above copyright notice and this paragraph
7 * in its entirety, and (2) distributions including binary code include
8 * the above copyright notice and this paragraph in its entirety in
9 * the documentation or other materials provided with the distribution.
10 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND
11 * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
12 * LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
13 * FOR A PARTICULAR PURPOSE.
14 *
15 * Original code by Hannes Gredler (hannes@juniper.net)
16 */
17
18/* \summary: Resource Public Key Infrastructure (RPKI) to Router Protocol printer */
19
20/* specification: RFC 6810 */
21
22#ifdef HAVE_CONFIG_H
23#include "config.h"
24#endif
25
26#include <netdissect-stdinc.h>
27
28#include <string.h>
29
30#include "netdissect.h"
31#include "extract.h"
32#include "addrtoname.h"
33
34static const char tstr[] = "[|RPKI-RTR]";
35
36/*
37 * RPKI/Router PDU header
38 *
39 * Here's what the PDU header looks like.
40 * The length does include the version and length fields.
41 */
42typedef struct rpki_rtr_pdu_ {
43    u_char version;		/* Version number */
44    u_char pdu_type;		/* PDU type */
45    union {
46	u_char session_id[2];	/* Session id */
47	u_char error_code[2];	/* Error code */
48    } u;
49    u_char length[4];
50} rpki_rtr_pdu;
51#define RPKI_RTR_PDU_OVERHEAD (offsetof(rpki_rtr_pdu, rpki_rtr_pdu_msg))
52
53/*
54 * IPv4 Prefix PDU.
55 */
56typedef struct rpki_rtr_pdu_ipv4_prefix_ {
57    rpki_rtr_pdu pdu_header;
58    u_char flags;
59    u_char prefix_length;
60    u_char max_length;
61    u_char zero;
62    u_char prefix[4];
63    u_char as[4];
64} rpki_rtr_pdu_ipv4_prefix;
65
66/*
67 * IPv6 Prefix PDU.
68 */
69typedef struct rpki_rtr_pdu_ipv6_prefix_ {
70    rpki_rtr_pdu pdu_header;
71    u_char flags;
72    u_char prefix_length;
73    u_char max_length;
74    u_char zero;
75    u_char prefix[16];
76    u_char as[4];
77} rpki_rtr_pdu_ipv6_prefix;
78
79/*
80 * Error report PDU.
81 */
82typedef struct rpki_rtr_pdu_error_report_ {
83    rpki_rtr_pdu pdu_header;
84    u_char encapsulated_pdu_length[4]; /* Encapsulated PDU length */
85} rpki_rtr_pdu_error_report;
86
87/*
88 * PDU type codes
89 */
90#define RPKI_RTR_SERIAL_NOTIFY_PDU	0
91#define RPKI_RTR_SERIAL_QUERY_PDU	1
92#define RPKI_RTR_RESET_QUERY_PDU	2
93#define RPKI_RTR_CACHE_RESPONSE_PDU	3
94#define RPKI_RTR_IPV4_PREFIX_PDU	4
95#define RPKI_RTR_IPV6_PREFIX_PDU	6
96#define RPKI_RTR_END_OF_DATA_PDU	7
97#define RPKI_RTR_CACHE_RESET_PDU	8
98#define RPKI_RTR_ERROR_REPORT_PDU	10
99
100static const struct tok rpki_rtr_pdu_values[] = {
101    { RPKI_RTR_SERIAL_NOTIFY_PDU, "Serial Notify" },
102    { RPKI_RTR_SERIAL_QUERY_PDU, "Serial Query" },
103    { RPKI_RTR_RESET_QUERY_PDU, "Reset Query" },
104    { RPKI_RTR_CACHE_RESPONSE_PDU, "Cache Response" },
105    { RPKI_RTR_IPV4_PREFIX_PDU, "IPV4 Prefix" },
106    { RPKI_RTR_IPV6_PREFIX_PDU, "IPV6 Prefix" },
107    { RPKI_RTR_END_OF_DATA_PDU, "End of Data" },
108    { RPKI_RTR_CACHE_RESET_PDU, "Cache Reset" },
109    { RPKI_RTR_ERROR_REPORT_PDU, "Error Report" },
110    { 0, NULL}
111};
112
113static const struct tok rpki_rtr_error_codes[] = {
114    { 0, "Corrupt Data" },
115    { 1, "Internal Error" },
116    { 2, "No Data Available" },
117    { 3, "Invalid Request" },
118    { 4, "Unsupported Protocol Version" },
119    { 5, "Unsupported PDU Type" },
120    { 6, "Withdrawal of Unknown Record" },
121    { 7, "Duplicate Announcement Received" },
122    { 0, NULL}
123};
124
125/*
126 * Build a indentation string for a given indentation level.
127 * XXX this should be really in util.c
128 */
129static char *
130indent_string (u_int indent)
131{
132    static char buf[20];
133    u_int idx;
134
135    idx = 0;
136    buf[idx] = '\0';
137
138    /*
139     * Does the static buffer fit ?
140     */
141    if (sizeof(buf) < ((indent/8) + (indent %8) + 2)) {
142	return buf;
143    }
144
145    /*
146     * Heading newline.
147     */
148    buf[idx] = '\n';
149    idx++;
150
151    while (indent >= 8) {
152	buf[idx] = '\t';
153	idx++;
154	indent -= 8;
155    }
156
157    while (indent > 0) {
158	buf[idx] = ' ';
159	idx++;
160	indent--;
161    }
162
163    /*
164     * Trailing zero.
165     */
166    buf[idx] = '\0';
167
168    return buf;
169}
170
171/*
172 * Print a single PDU.
173 */
174static int
175rpki_rtr_pdu_print (netdissect_options *ndo, const u_char *tptr, u_int indent)
176{
177    const rpki_rtr_pdu *pdu_header;
178    u_int pdu_type, pdu_len, hexdump;
179    const u_char *msg;
180
181    pdu_header = (const rpki_rtr_pdu *)tptr;
182    pdu_type = pdu_header->pdu_type;
183    pdu_len = EXTRACT_32BITS(pdu_header->length);
184    ND_TCHECK2(*tptr, pdu_len);
185    hexdump = FALSE;
186
187    ND_PRINT((ndo, "%sRPKI-RTRv%u, %s PDU (%u), length: %u",
188	   indent_string(8),
189	   pdu_header->version,
190	   tok2str(rpki_rtr_pdu_values, "Unknown", pdu_type),
191	   pdu_type, pdu_len));
192
193    switch (pdu_type) {
194
195	/*
196	 * The following PDUs share the message format.
197	 */
198    case RPKI_RTR_SERIAL_NOTIFY_PDU:
199    case RPKI_RTR_SERIAL_QUERY_PDU:
200    case RPKI_RTR_END_OF_DATA_PDU:
201        msg = (const u_char *)(pdu_header + 1);
202	ND_PRINT((ndo, "%sSession ID: 0x%04x, Serial: %u",
203	       indent_string(indent+2),
204	       EXTRACT_16BITS(pdu_header->u.session_id),
205	       EXTRACT_32BITS(msg)));
206	break;
207
208	/*
209	 * The following PDUs share the message format.
210	 */
211    case RPKI_RTR_RESET_QUERY_PDU:
212    case RPKI_RTR_CACHE_RESET_PDU:
213
214	/*
215	 * Zero payload PDUs.
216	 */
217	break;
218
219    case RPKI_RTR_CACHE_RESPONSE_PDU:
220	ND_PRINT((ndo, "%sSession ID: 0x%04x",
221	       indent_string(indent+2),
222	       EXTRACT_16BITS(pdu_header->u.session_id)));
223	break;
224
225    case RPKI_RTR_IPV4_PREFIX_PDU:
226	{
227	    const rpki_rtr_pdu_ipv4_prefix *pdu;
228
229	    pdu = (const rpki_rtr_pdu_ipv4_prefix *)tptr;
230	    ND_PRINT((ndo, "%sIPv4 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",
231		   indent_string(indent+2),
232		   ipaddr_string(ndo, pdu->prefix),
233		   pdu->prefix_length, pdu->max_length,
234		   EXTRACT_32BITS(pdu->as), pdu->flags));
235	}
236	break;
237
238    case RPKI_RTR_IPV6_PREFIX_PDU:
239	{
240	    const rpki_rtr_pdu_ipv6_prefix *pdu;
241
242	    pdu = (const rpki_rtr_pdu_ipv6_prefix *)tptr;
243	    ND_PRINT((ndo, "%sIPv6 Prefix %s/%u-%u, origin-as %u, flags 0x%02x",
244		   indent_string(indent+2),
245		   ip6addr_string(ndo, pdu->prefix),
246		   pdu->prefix_length, pdu->max_length,
247		   EXTRACT_32BITS(pdu->as), pdu->flags));
248	}
249	break;
250
251    case RPKI_RTR_ERROR_REPORT_PDU:
252	{
253	    const rpki_rtr_pdu_error_report *pdu;
254	    u_int encapsulated_pdu_length, text_length, tlen, error_code;
255
256	    pdu = (const rpki_rtr_pdu_error_report *)tptr;
257	    encapsulated_pdu_length = EXTRACT_32BITS(pdu->encapsulated_pdu_length);
258	    ND_TCHECK2(*tptr, encapsulated_pdu_length);
259	    tlen = pdu_len;
260
261	    error_code = EXTRACT_16BITS(pdu->pdu_header.u.error_code);
262	    ND_PRINT((ndo, "%sError code: %s (%u), Encapsulated PDU length: %u",
263		   indent_string(indent+2),
264		   tok2str(rpki_rtr_error_codes, "Unknown", error_code),
265		   error_code, encapsulated_pdu_length));
266
267	    tptr += sizeof(*pdu);
268	    tlen -= sizeof(*pdu);
269
270	    /*
271	     * Recurse if there is an encapsulated PDU.
272	     */
273	    if (encapsulated_pdu_length &&
274		(encapsulated_pdu_length <= tlen)) {
275		ND_PRINT((ndo, "%s-----encapsulated PDU-----", indent_string(indent+4)));
276		if (rpki_rtr_pdu_print(ndo, tptr, indent+2))
277			goto trunc;
278	    }
279
280	    tptr += encapsulated_pdu_length;
281	    tlen -= encapsulated_pdu_length;
282
283	    /*
284	     * Extract, trail-zero and print the Error message.
285	     */
286	    text_length = 0;
287	    if (tlen > 4) {
288		text_length = EXTRACT_32BITS(tptr);
289		tptr += 4;
290		tlen -= 4;
291	    }
292	    ND_TCHECK2(*tptr, text_length);
293	    if (text_length && (text_length <= tlen )) {
294		ND_PRINT((ndo, "%sError text: ", indent_string(indent+2)));
295		if (fn_printn(ndo, tptr, text_length, ndo->ndo_snapend))
296			goto trunc;
297	    }
298	}
299	break;
300
301    default:
302
303	/*
304	 * Unknown data, please hexdump.
305	 */
306	hexdump = TRUE;
307    }
308
309    /* do we also want to see a hex dump ? */
310    if (ndo->ndo_vflag > 1 || (ndo->ndo_vflag && hexdump)) {
311	print_unknown_data(ndo,tptr,"\n\t  ", pdu_len);
312    }
313    return 0;
314
315trunc:
316    return 1;
317}
318
319void
320rpki_rtr_print(netdissect_options *ndo, register const u_char *pptr, register u_int len)
321{
322    u_int tlen, pdu_type, pdu_len;
323    const u_char *tptr;
324    const rpki_rtr_pdu *pdu_header;
325
326    tptr = pptr;
327    tlen = len;
328
329    if (!ndo->ndo_vflag) {
330	ND_PRINT((ndo, ", RPKI-RTR"));
331	return;
332    }
333
334    while (tlen >= sizeof(rpki_rtr_pdu)) {
335
336        ND_TCHECK2(*tptr, sizeof(rpki_rtr_pdu));
337
338	pdu_header = (const rpki_rtr_pdu *)tptr;
339        pdu_type = pdu_header->pdu_type;
340        pdu_len = EXTRACT_32BITS(pdu_header->length);
341        ND_TCHECK2(*tptr, pdu_len);
342
343        /* infinite loop check */
344        if (!pdu_type || !pdu_len) {
345            break;
346        }
347
348        if (tlen < pdu_len) {
349            goto trunc;
350        }
351
352	/*
353	 * Print the PDU.
354	 */
355	if (rpki_rtr_pdu_print(ndo, tptr, 8))
356		goto trunc;
357
358        tlen -= pdu_len;
359        tptr += pdu_len;
360    }
361    return;
362trunc:
363    ND_PRINT((ndo, "\n\t%s", tstr));
364}
365
366/*
367 * Local Variables:
368 * c-style: whitesmith
369 * c-basic-offset: 4
370 * End:
371 */
372