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  * support for the The RPKI/Router Protocol Protocol as per draft-ietf-sidr-rpki-rtr-12
  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 cache_nonce[2];  /* Cache Nonce */
  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("%sCache-Nonce: 0x%04x, Serial: %u",
 205                indent_string(indent+2),
 206                EXTRACT_16BITS(pdu_header->u.cache_nonce),
 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("%sCache-Nonce: 0x%04x",
 223                indent_string(indent+2),
 224                EXTRACT_16BITS(pdu_header->u.cache_nonce));
 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  */