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