X-Git-Url: https://git.tcpdump.org/tcpdump/blobdiff_plain/69cb46af9119e8b5554bcc4bf1bf36f39cb82131..d2777156522f139a858bd6b5b51e364826bc95a7:/print-rip.c diff --git a/print-rip.c b/print-rip.c index 3c64bf9a..fca534fb 100644 --- a/print-rip.c +++ b/print-rip.c @@ -19,26 +19,36 @@ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ +/* \summary: Routing Information Protocol (RIP) printer */ + +/* specification: RFC 1058, RFC 2453, RFC 4822 */ + #ifdef HAVE_CONFIG_H -#include "config.h" +#include #endif -#include - -#include +#include "netdissect-stdinc.h" -#include "interface.h" +#include "netdissect.h" #include "addrtoname.h" -#include "extract.h" /* must come after interface.h */ +#include "extract.h" #include "af.h" -static const char tstr[] = "[|rip]"; +/* + * RFC 1058 and RFC 2453 header of packet. + * + * 0 1 2 3 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Command (1) | Version (1) | unused | + * +---------------+---------------+-------------------------------+ + */ struct rip { - uint8_t rip_cmd; /* request/response */ - uint8_t rip_vers; /* protocol version # */ - uint8_t unused[2]; /* unused */ + nd_uint8_t rip_cmd; /* request/response */ + nd_uint8_t rip_vers; /* protocol version # */ + nd_byte unused[2]; /* unused */ }; #define RIPCMD_REQUEST 1 /* want info */ @@ -62,13 +72,46 @@ static const struct tok rip_cmd_values[] = { #define RIP_ROUTELEN 20 /* - * rfc 1723 + * First 4 bytes of all RIPv1/RIPv2 entries. + */ +struct rip_entry_header { + nd_uint16_t rip_family; + nd_uint16_t rip_tag; +}; + +/* + * RFC 1058 entry. + * + * 0 1 2 3 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Address Family Identifier (2) | must be zero (2) | + * +-------------------------------+-------------------------------+ + * | IP Address (4) | + * +---------------------------------------------------------------+ + * | must be zero (4) | + * +---------------------------------------------------------------+ + * | must be zero (4) | + * +---------------------------------------------------------------+ + * | Metric (4) | + * +---------------------------------------------------------------+ + */ +struct rip_netinfo_v1 { + nd_uint16_t rip_family; + nd_byte rip_mbz1[2]; + nd_ipv4 rip_dest; + nd_byte rip_mbz2[4]; + nd_byte rip_mbz3[4]; + nd_uint32_t rip_metric; /* cost of route */ +}; + + +/* + * RFC 2453 route entry * * 0 1 2 3 3 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * | Command (1) | Version (1) | unused | - * +---------------+---------------+-------------------------------+ * | Address Family Identifier (2) | Route Tag (2) | * +-------------------------------+-------------------------------+ * | IP Address (4) | @@ -82,125 +125,199 @@ static const struct tok rip_cmd_values[] = { * */ -struct rip_netinfo { - uint16_t rip_family; - uint16_t rip_tag; - uint32_t rip_dest; - uint32_t rip_dest_mask; - uint32_t rip_router; - uint32_t rip_metric; /* cost of route */ +struct rip_netinfo_v2 { + nd_uint16_t rip_family; + nd_uint16_t rip_tag; + nd_ipv4 rip_dest; + nd_uint32_t rip_dest_mask; + nd_ipv4 rip_router; + nd_uint32_t rip_metric; /* cost of route */ }; -static void -rip_entry_print_v1(netdissect_options *ndo, - register const struct rip_netinfo *ni) +/* + * RFC 2453 authentication entry + * + * 0 1 2 3 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | 0xFFFF | Authentication Type (2) | + * +-------------------------------+-------------------------------+ + * - Authentication (16) - + * +---------------------------------------------------------------+ + */ + +struct rip_auth_v2 { + nd_uint16_t rip_family; + nd_uint16_t rip_tag; + nd_byte rip_auth[16]; +}; + +/* + * RFC 4822 Cryptographic Authentication entry. + * + * 0 1 2 3 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | RIPv2 Packet Length | Key ID | Auth Data Len | + * +---------------+---------------+---------------+---------------+ + * | Sequence Number (non-decreasing) | + * +---------------+---------------+---------------+---------------+ + * | reserved must be zero | + * +---------------+---------------+---------------+---------------+ + * | reserved must be zero | + * +---------------+---------------+---------------+---------------+ + */ +struct rip_auth_crypto_v2 { + nd_uint16_t rip_packet_len; + nd_uint8_t rip_key_id; + nd_uint8_t rip_auth_data_len; + nd_uint32_t rip_seq_num; + nd_byte rip_mbz1[4]; + nd_byte rip_mbz2[4]; +}; + +static unsigned +rip_entry_print_v1(netdissect_options *ndo, const u_char *p, + unsigned remaining) { - register u_short family; + const struct rip_entry_header *eh = (const struct rip_entry_header *)p; + u_short family; + const struct rip_netinfo_v1 *ni = (const struct rip_netinfo_v1 *)p; /* RFC 1058 */ - family = EXTRACT_16BITS(&ni->rip_family); + if (remaining < RIP_ROUTELEN) + return (0); + ND_TCHECK_SIZE(ni); + family = GET_BE_U_2(ni->rip_family); if (family != BSD_AFNUM_INET && family != 0) { - ND_PRINT((ndo, "\n\t AFI %s, ", tok2str(bsd_af_values, "Unknown (%u)", family))); - print_unknown_data(ndo, (const uint8_t *)&ni->rip_family, "\n\t ", RIP_ROUTELEN); - return; + ND_PRINT("\n\t AFI %s, ", tok2str(bsd_af_values, "Unknown (%u)", family)); + print_unknown_data(ndo, p + sizeof(*eh), "\n\t ", RIP_ROUTELEN - sizeof(*eh)); + return (RIP_ROUTELEN); } - if (EXTRACT_16BITS(&ni->rip_tag) || - EXTRACT_32BITS(&ni->rip_dest_mask) || - EXTRACT_32BITS(&ni->rip_router)) { + if (GET_BE_U_2(ni->rip_mbz1) || + GET_BE_U_4(ni->rip_mbz2) || + GET_BE_U_4(ni->rip_mbz3)) { /* MBZ fields not zero */ - print_unknown_data(ndo, (const uint8_t *)&ni->rip_family, "\n\t ", RIP_ROUTELEN); - return; + print_unknown_data(ndo, p, "\n\t ", RIP_ROUTELEN); + return (RIP_ROUTELEN); } if (family == 0) { - ND_PRINT((ndo, "\n\t AFI 0, %s, metric: %u", - ipaddr_string(ndo, &ni->rip_dest), - EXTRACT_32BITS(&ni->rip_metric))); - return; + ND_PRINT("\n\t AFI 0, %s, metric: %u", + GET_IPADDR_STRING(ni->rip_dest), + GET_BE_U_4(ni->rip_metric)); + return (RIP_ROUTELEN); } /* BSD_AFNUM_INET */ - ND_PRINT((ndo, "\n\t %s, metric: %u", - ipaddr_string(ndo, &ni->rip_dest), - EXTRACT_32BITS(&ni->rip_metric))); + ND_PRINT("\n\t %s, metric: %u", + GET_IPADDR_STRING(ni->rip_dest), + GET_BE_U_4(ni->rip_metric)); + return (RIP_ROUTELEN); +trunc: + return 0; } static unsigned -rip_entry_print_v2(netdissect_options *ndo, - register const struct rip_netinfo *ni, const unsigned remaining) +rip_entry_print_v2(netdissect_options *ndo, const u_char *p, + unsigned remaining) { - register u_short family; + const struct rip_entry_header *eh = (const struct rip_entry_header *)p; + u_short family; + const struct rip_netinfo_v2 *ni; - family = EXTRACT_16BITS(&ni->rip_family); + if (remaining < sizeof(*eh)) + return (0); + ND_TCHECK_SIZE(eh); + family = GET_BE_U_2(eh->rip_family); if (family == 0xFFFF) { /* variable-sized authentication structures */ - uint16_t auth_type = EXTRACT_16BITS(&ni->rip_tag); + uint16_t auth_type = GET_BE_U_2(eh->rip_tag); + + p += sizeof(*eh); + remaining -= sizeof(*eh); if (auth_type == 2) { - register const u_char *p = (const u_char *)&ni->rip_dest; - u_int i = 0; - ND_PRINT((ndo, "\n\t Simple Text Authentication data: ")); - for (; i < RIP_AUTHLEN; p++, i++) - ND_PRINT((ndo, "%c", ND_ISPRINT(*p) ? *p : '.')); + ND_PRINT("\n\t Simple Text Authentication data: "); + nd_printjnp(ndo, p, RIP_AUTHLEN); } else if (auth_type == 3) { - ND_PRINT((ndo, "\n\t Auth header:")); - ND_PRINT((ndo, " Packet Len %u,", EXTRACT_16BITS((const uint8_t *)ni + 4))); - ND_PRINT((ndo, " Key-ID %u,", *((const uint8_t *)ni + 6))); - ND_PRINT((ndo, " Auth Data Len %u,", *((const uint8_t *)ni + 7))); - ND_PRINT((ndo, " SeqNo %u,", EXTRACT_32BITS(&ni->rip_dest_mask))); - ND_PRINT((ndo, " MBZ %u,", EXTRACT_32BITS(&ni->rip_router))); - ND_PRINT((ndo, " MBZ %u", EXTRACT_32BITS(&ni->rip_metric))); + const struct rip_auth_crypto_v2 *ch; + + ch = (const struct rip_auth_crypto_v2 *)p; + ND_TCHECK_SIZE(ch); + if (remaining < sizeof(*ch)) + return (0); + ND_PRINT("\n\t Auth header:"); + ND_PRINT(" Packet Len %u,", + GET_BE_U_2(ch->rip_packet_len)); + ND_PRINT(" Key-ID %u,", GET_U_1(ch->rip_key_id)); + ND_PRINT(" Auth Data Len %u,", + GET_U_1(ch->rip_auth_data_len)); + ND_PRINT(" SeqNo %u,", GET_BE_U_4(ch->rip_seq_num)); + ND_PRINT(" MBZ %u,", GET_BE_U_4(ch->rip_mbz1)); + ND_PRINT(" MBZ %u", GET_BE_U_4(ch->rip_mbz2)); } else if (auth_type == 1) { - ND_PRINT((ndo, "\n\t Auth trailer:")); - print_unknown_data(ndo, (const uint8_t *)&ni->rip_dest, "\n\t ", remaining); - return remaining; /* AT spans till the packet end */ + ND_PRINT("\n\t Auth trailer:"); + print_unknown_data(ndo, p, "\n\t ", remaining); + return (sizeof(*eh) + remaining); /* AT spans till the packet end */ } else { - ND_PRINT((ndo, "\n\t Unknown (%u) Authentication data:", - EXTRACT_16BITS(&ni->rip_tag))); - print_unknown_data(ndo, (const uint8_t *)&ni->rip_dest, "\n\t ", remaining); + ND_PRINT("\n\t Unknown (%u) Authentication data:", + auth_type); + print_unknown_data(ndo, p, "\n\t ", remaining); + return (sizeof(*eh) + remaining); /* we don't know how long this is, so we go to the packet end */ } } else if (family != BSD_AFNUM_INET && family != 0) { - ND_PRINT((ndo, "\n\t AFI %s", tok2str(bsd_af_values, "Unknown (%u)", family))); - print_unknown_data(ndo, (const uint8_t *)&ni->rip_tag, "\n\t ", RIP_ROUTELEN-2); + ND_PRINT("\n\t AFI %s", tok2str(bsd_af_values, "Unknown (%u)", family)); + print_unknown_data(ndo, p + sizeof(*eh), "\n\t ", RIP_ROUTELEN - sizeof(*eh)); } else { /* BSD_AFNUM_INET or AFI 0 */ - ND_PRINT((ndo, "\n\t AFI %s, %15s/%-2d, tag 0x%04x, metric: %u, next-hop: ", - tok2str(bsd_af_values, "%u", family), - ipaddr_string(ndo, &ni->rip_dest), - mask2plen(EXTRACT_32BITS(&ni->rip_dest_mask)), - EXTRACT_16BITS(&ni->rip_tag), - EXTRACT_32BITS(&ni->rip_metric))); - if (EXTRACT_32BITS(&ni->rip_router)) - ND_PRINT((ndo, "%s", ipaddr_string(ndo, &ni->rip_router))); + ni = (const struct rip_netinfo_v2 *)p; + ND_TCHECK_SIZE(ni); + if (remaining < sizeof(*ni)) + return (0); + ND_PRINT("\n\t AFI %s, %15s/%-2d, tag 0x%04x, metric: %u, next-hop: ", + tok2str(bsd_af_values, "%u", family), + GET_IPADDR_STRING(ni->rip_dest), + mask2plen(GET_BE_U_4(ni->rip_dest_mask)), + GET_BE_U_2(ni->rip_tag), + GET_BE_U_4(ni->rip_metric)); + if (GET_BE_U_4(ni->rip_router)) + ND_PRINT("%s", GET_IPADDR_STRING(ni->rip_router)); else - ND_PRINT((ndo, "self")); + ND_PRINT("self"); } - return sizeof (*ni); + return (RIP_ROUTELEN); +trunc: + return 0; } void rip_print(netdissect_options *ndo, - const u_char *dat, u_int length) + const u_char *dat, u_int length) { - register const struct rip *rp; - register const struct rip_netinfo *ni; - register u_int i, j; + const struct rip *rp; + uint8_t vers, cmd; + const u_char *p; + u_int len, routecount; + unsigned entry_size; + ndo->ndo_protocol = "rip"; if (ndo->ndo_snapend < dat) { - ND_PRINT((ndo, " %s", tstr)); + nd_print_trunc(ndo); return; } - i = ndo->ndo_snapend - dat; - if (i > length) - i = length; - if (i < sizeof(*rp)) { - ND_PRINT((ndo, " %s", tstr)); + len = ND_BYTES_AVAILABLE_AFTER(dat); + if (len > length) + len = length; + if (len < sizeof(*rp)) { + nd_print_trunc(ndo); return; } - i -= sizeof(*rp); + len -= sizeof(*rp); rp = (const struct rip *)dat; - ND_PRINT((ndo, "%sRIPv%u", - (ndo->ndo_vflag >= 1) ? "\n\t" : "", - rp->rip_vers)); + ND_TCHECK_SIZE(rp); + vers = GET_U_1(rp->rip_vers); + ND_PRINT("%sRIPv%u", + (ndo->ndo_vflag >= 1) ? "\n\t" : "", + vers); - switch (rp->rip_vers) { - case 0: + if (vers == 0) { /* * RFC 1058. * @@ -212,60 +329,94 @@ rip_print(netdissect_options *ndo, * * so perhaps we should just dump the packet, in hex. */ - print_unknown_data(ndo, (const uint8_t *)&rp->rip_cmd, "\n\t", length); - break; - default: - /* dump version and lets see if we know the commands name*/ - ND_PRINT((ndo, ", %s, length: %u", - tok2str(rip_cmd_values, - "unknown command (%u)", - rp->rip_cmd), - length)); - - if (ndo->ndo_vflag < 1) - return; - - switch (rp->rip_cmd) { - case RIPCMD_REQUEST: - case RIPCMD_RESPONSE: - j = length / sizeof(*ni); - ND_PRINT((ndo, ", routes: %u%s", j, rp->rip_vers == 2 ? " or less" : "")); - ni = (const struct rip_netinfo *)(rp + 1); - for (; i >= sizeof(*ni); ++ni) { - if (rp->rip_vers == 1) - { - rip_entry_print_v1(ndo, ni); - i -= sizeof(*ni); + print_unknown_data(ndo, (const uint8_t *)&rp->rip_cmd, "\n\t", length); + return; + } + + /* dump version and lets see if we know the commands name*/ + cmd = GET_U_1(rp->rip_cmd); + ND_PRINT(", %s, length: %u", + tok2str(rip_cmd_values, "unknown command (%u)", cmd), + length); + + if (ndo->ndo_vflag < 1) + return; + + switch (cmd) { + + case RIPCMD_REQUEST: + case RIPCMD_RESPONSE: + switch (vers) { + + case 1: + routecount = length / RIP_ROUTELEN; + ND_PRINT(", routes: %u", routecount); + p = (const u_char *)(rp + 1); + while (len != 0) { + entry_size = rip_entry_print_v1(ndo, p, len); + if (entry_size == 0) { + /* Error */ + nd_print_trunc(ndo); + break; } - else if (rp->rip_vers == 2) - i -= rip_entry_print_v2(ndo, ni, i); - else - break; + if (len < entry_size) { + ND_PRINT(" [remaining entries length %u < %u]", + len, entry_size); + nd_print_invalid(ndo); + break; + } + p += entry_size; + len -= entry_size; } - if (i) - ND_PRINT((ndo, "%s", tstr)); break; - case RIPCMD_TRACEOFF: - case RIPCMD_POLL: - case RIPCMD_POLLENTRY: + case 2: + routecount = length / RIP_ROUTELEN; + ND_PRINT(", routes: %u or less", routecount); + p = (const u_char *)(rp + 1); + while (len != 0) { + entry_size = rip_entry_print_v2(ndo, p, len); + if (entry_size == 0) { + /* Error */ + nd_print_trunc(ndo); + break; + } + if (len < entry_size) { + ND_PRINT(" [remaining entries length %u < %u]", + len, entry_size); + nd_print_invalid(ndo); + break; + } + p += entry_size; + len -= entry_size; + } break; - case RIPCMD_TRACEON: - /* fall through */ - default: - if (ndo->ndo_vflag <= 1) { - if(!print_unknown_data(ndo, (const uint8_t *)rp, "\n\t", length)) - return; - } - break; - } - /* do we want to see an additionally hexdump ? */ - if (ndo->ndo_vflag> 1) { - if(!print_unknown_data(ndo, (const uint8_t *)rp, "\n\t", length)) - return; - } - } -} + default: + ND_PRINT(", unknown version"); + break; + } + break; + case RIPCMD_TRACEOFF: + case RIPCMD_POLL: + case RIPCMD_POLLENTRY: + break; + case RIPCMD_TRACEON: + /* fall through */ + default: + if (ndo->ndo_vflag <= 1) { + if (!print_unknown_data(ndo, (const uint8_t *)rp, "\n\t", length)) + return; + } + break; + } + /* do we want to see an additionally hexdump ? */ + if (ndo->ndo_vflag> 1) { + if (!print_unknown_data(ndo, (const uint8_t *)rp, "\n\t", length)) + return; + } +trunc: + return; +}