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