contrib/tcpdump/print-rpki-rtr.c

   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
  34 static 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  */
  42 typedef 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  */
  56 typedef 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  */
  69 typedef 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  */
  82 typedef 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
 100 static 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
 113 static 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  */
 129 static char *
 130 indent_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  */
 174 static int
 175 rpki_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
 315 trunc:
 316     return 1;
 317 }
 318
 319 void
 320 rpki_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;
 362 trunc:
 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  */