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