]> The Tcpdump Group git mirrors - tcpdump/blobdiff - print-lisp.c
projects / tcpdump / blobdiff
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
CHANGES: Add/move change(s) backported to 4.99
[tcpdump] / print-lisp.c
diff --git a/print-lisp.c b/print-lisp.c
index 8d064023c729562b7e7069a70dee7dae75b5e591..da131226579765cd44548515c98dea7cd91c55cb 100644 (file)
--- a/print-lisp.c
+++ b/print-lisp.c
@@ -94,14 +94,10 @@
  *  +-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  */
 
  *  +-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  */
 
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
+#include <config.h>
 
 
-#include <netdissect-stdinc.h>
+#include "netdissect-stdinc.h"
 #include "netdissect.h"
 #include "netdissect.h"
-#include <string.h>
-#include <stdlib.h>
 
 #include "ip.h"
 #include "ip6.h"
 
 #include "ip.h"
 #include "ip6.h"
@@ -109,7 +105,6 @@
 #include "extract.h"
 #include "addrtoname.h"
 
 #include "extract.h"
 #include "addrtoname.h"
 
-static const char tstr[] = " [|LISP]";
 
 #define IPv4_AFI                       1
 #define IPv6_AFI                       2
 
 #define IPv4_AFI                       1
 #define IPv6_AFI                       2
@@ -132,12 +127,12 @@ enum {
 };
 
 static const struct tok lisp_type [] = {
 };
 
 static const struct tok lisp_type [] = {
-       { 0, "LISP-Reserved"                    },
-       { 1, "LISP-Map-Request"                 },
-       { 2, "LISP-Map-Reply"                   },
-       { 3, "LISP-Map-Register"                },
-       { 4, "LISP-Map-Notify"                  },
-       { 8, "LISP-Encapsulated-Contol-Message" },
+       { 0, "LISP-Reserved"                     },
+       { 1, "LISP-Map-Request"                  },
+       { 2, "LISP-Map-Reply"                    },
+       { 3, "LISP-Map-Register"                 },
+       { 4, "LISP-Map-Notify"                   },
+       { 8, "LISP-Encapsulated-Control-Message" },
        { 0, NULL }
 };
 
        { 0, NULL }
 };
 
@@ -205,8 +200,7 @@ typedef struct map_register_eid {
        nd_uint8_t eid_prefix_mask_length;
        nd_uint8_t act_auth_inc_res;
        nd_uint8_t reserved;
        nd_uint8_t eid_prefix_mask_length;
        nd_uint8_t act_auth_inc_res;
        nd_uint8_t reserved;
-       nd_uint8_t reserved_version_hi;
-       nd_uint8_t version_low;
+       nd_uint16_t reserved_and_version;
        nd_uint16_t eid_prefix_afi;
 } lisp_map_register_eid;
 
        nd_uint16_t eid_prefix_afi;
 } lisp_map_register_eid;
 
@@ -223,8 +217,8 @@ typedef struct map_register_loc {
 
 #define MAP_REGISTER_LOC_LEN sizeof(lisp_map_register_loc)
 
 
 #define MAP_REGISTER_LOC_LEN sizeof(lisp_map_register_loc)
 
-static inline uint8_t extract_lisp_type(uint8_t);
-static inline uint8_t is_xtr_data_present(uint8_t , uint8_t);
+static uint8_t extract_lisp_type(uint8_t);
+static uint8_t is_xtr_data_present(uint8_t, uint8_t);
 static void lisp_hdr_flag(netdissect_options *, const lisp_map_register_hdr *);
 static void action_flag(netdissect_options *, uint8_t);
 static void loc_hdr_flag(netdissect_options *, uint16_t);
 static void lisp_hdr_flag(netdissect_options *, const lisp_map_register_hdr *);
 static void action_flag(netdissect_options *, uint8_t);
 static void loc_hdr_flag(netdissect_options *, uint16_t);
@@ -232,6 +226,7 @@ static void loc_hdr_flag(netdissect_options *, uint16_t);
 void
 lisp_print(netdissect_options *ndo, const u_char *bp, u_int length)
 {
 void
 lisp_print(netdissect_options *ndo, const u_char *bp, u_int length)
 {
+       uint8_t type_and_flag;
        uint8_t type;
        uint8_t mask_len;
        uint8_t loc_count;
        uint8_t type;
        uint8_t mask_len;
        uint8_t loc_count;
@@ -250,33 +245,35 @@ lisp_print(netdissect_options *ndo, const u_char *bp, u_int length)
        const lisp_map_register_eid *lisp_eid;
        const lisp_map_register_loc *lisp_loc;
 
        const lisp_map_register_eid *lisp_eid;
        const lisp_map_register_loc *lisp_loc;
 
+       ndo->ndo_protocol = "lisp";
        /* Check if enough bytes for header are available */
        /* Check if enough bytes for header are available */
-       ND_TCHECK2(*bp, MAP_REGISTER_HDR_LEN);
+       ND_TCHECK_LEN(bp, MAP_REGISTER_HDR_LEN);
        lisp_hdr = (const lisp_map_register_hdr *) bp;
        lisp_hdr_flag(ndo, lisp_hdr);
        /* Supporting only MAP NOTIFY and MAP REGISTER LISP packets */
        lisp_hdr = (const lisp_map_register_hdr *) bp;
        lisp_hdr_flag(ndo, lisp_hdr);
        /* Supporting only MAP NOTIFY and MAP REGISTER LISP packets */
-       type = extract_lisp_type(lisp_hdr->type_and_flag);
+       type_and_flag = GET_U_1(lisp_hdr->type_and_flag);
+       type = extract_lisp_type(type_and_flag);
        if ((type != LISP_MAP_REGISTER) && (type != LISP_MAP_NOTIFY))
                return;
 
        /* Find if the packet contains xTR and Site-ID data */
        if ((type != LISP_MAP_REGISTER) && (type != LISP_MAP_NOTIFY))
                return;
 
        /* Find if the packet contains xTR and Site-ID data */
-       xtr_present = is_xtr_data_present(type, lisp_hdr->type_and_flag);
+       xtr_present = is_xtr_data_present(type, type_and_flag);
 
        /* Extract the number of EID records present */
 
        /* Extract the number of EID records present */
-       auth_data_len = EXTRACT_BE_16BITS(&lisp_hdr->auth_data_len);
+       auth_data_len = GET_BE_U_2(lisp_hdr->auth_data_len);
        packet_iterator = (const u_char *)(lisp_hdr);
        packet_offset = MAP_REGISTER_HDR_LEN;
        packet_iterator = (const u_char *)(lisp_hdr);
        packet_offset = MAP_REGISTER_HDR_LEN;
-       record_count = lisp_hdr->record_count;
+       record_count = GET_U_1(lisp_hdr->record_count);
 
        if (ndo->ndo_vflag) {
 
        if (ndo->ndo_vflag) {
-               key_id = EXTRACT_BE_16BITS(&lisp_hdr->key_id);
-               ND_PRINT((ndo, "\n    %u record(s), ", record_count));
-               ND_PRINT((ndo, "Authentication %s,",
-                       tok2str(auth_type, "unknown-type", key_id)));
+               key_id = GET_BE_U_2(lisp_hdr->key_id);
+               ND_PRINT("\n    %u record(s), ", record_count);
+               ND_PRINT("Authentication %s,",
+                       tok2str(auth_type, "unknown-type", key_id));
                hex_print(ndo, "\n    Authentication-Data: ", packet_iterator +
                                                packet_offset, auth_data_len);
        } else {
                hex_print(ndo, "\n    Authentication-Data: ", packet_iterator +
                                                packet_offset, auth_data_len);
        } else {
-               ND_PRINT((ndo, " %u record(s),", record_count));
+               ND_PRINT(" %u record(s),", record_count);
        }
        packet_offset += auth_data_len;
 
        }
        packet_offset += auth_data_len;
 
@@ -284,37 +281,37 @@ lisp_print(netdissect_options *ndo, const u_char *bp, u_int length)
                goto invalid;
 
        /* Print all the EID records */
                goto invalid;
 
        /* Print all the EID records */
-       while ((length > packet_offset) && (record_count--)) {
-
-               ND_TCHECK2(*(packet_iterator + packet_offset), MAP_REGISTER_EID_LEN);
-               ND_PRINT((ndo, "\n"));
+       while ((length > packet_offset) && (record_count != 0)) {
+               record_count--;
+               ND_TCHECK_LEN(packet_iterator + packet_offset,
+                             MAP_REGISTER_EID_LEN);
+               ND_PRINT("\n");
                lisp_eid = (const lisp_map_register_eid *)
                                ((const u_char *)lisp_hdr + packet_offset);
                packet_offset += MAP_REGISTER_EID_LEN;
                lisp_eid = (const lisp_map_register_eid *)
                                ((const u_char *)lisp_hdr + packet_offset);
                packet_offset += MAP_REGISTER_EID_LEN;
-               mask_len = lisp_eid->eid_prefix_mask_length;
-               eid_afi = EXTRACT_BE_16BITS(&lisp_eid->eid_prefix_afi);
-               loc_count = lisp_eid->locator_count;
+               mask_len = GET_U_1(lisp_eid->eid_prefix_mask_length);
+               eid_afi = GET_BE_U_2(lisp_eid->eid_prefix_afi);
+               loc_count = GET_U_1(lisp_eid->locator_count);
 
                if (ndo->ndo_vflag) {
 
                if (ndo->ndo_vflag) {
-                       ttl = EXTRACT_BE_32BITS(&lisp_eid->ttl);
-                       ND_PRINT((ndo, "      Record TTL %u,", ttl));
-                       action_flag(ndo, lisp_eid->act_auth_inc_res);
-                       map_version = (((lisp_eid->reserved_version_hi) & 15 ) * 255) +
-                                       lisp_eid->version_low;
-                       ND_PRINT((ndo, " Map Version: %u,", map_version));
+                       ttl = GET_BE_U_4(lisp_eid->ttl);
+                       ND_PRINT("      Record TTL %u,", ttl);
+                       action_flag(ndo, GET_U_1(lisp_eid->act_auth_inc_res));
+                       map_version = GET_BE_U_2(lisp_eid->reserved_and_version) & 0x0FFF;
+                       ND_PRINT(" Map Version: %u,", map_version);
                }
 
                switch (eid_afi) {
                case IPv4_AFI:
                }
 
                switch (eid_afi) {
                case IPv4_AFI:
-                       ND_TCHECK2(*(packet_iterator + packet_offset), 4);
-                       ND_PRINT((ndo, " EID %s/%u,", ipaddr_string(ndo,
-                               packet_iterator + packet_offset), mask_len));
+                       ND_PRINT(" EID %s/%u,",
+                               GET_IPADDR_STRING(packet_iterator + packet_offset),
+                               mask_len);
                        packet_offset += 4;
                        break;
                case IPv6_AFI:
                        packet_offset += 4;
                        break;
                case IPv6_AFI:
-                       ND_TCHECK2(*(packet_iterator + packet_offset), 16);
-                       ND_PRINT((ndo, " EID %s/%u,", ip6addr_string(ndo,
-                               packet_iterator + packet_offset), mask_len));
+                       ND_PRINT(" EID %s/%u,",
+                               GET_IP6ADDR_STRING(packet_iterator + packet_offset),
+                               mask_len);
                        packet_offset += 16;
                        break;
                default:
                        packet_offset += 16;
                        break;
                default:
@@ -325,39 +322,43 @@ lisp_print(netdissect_options *ndo, const u_char *bp, u_int length)
                        break;
                }
 
                        break;
                }
 
-               ND_PRINT((ndo, " %u locator(s)", loc_count));
+               ND_PRINT(" %u locator(s)", loc_count);
 
 
-               while (loc_count--) {
-                       ND_TCHECK2(*(packet_iterator + packet_offset), MAP_REGISTER_LOC_LEN);
+               while (loc_count != 0) {
+                       loc_count--;
+                       ND_TCHECK_LEN(packet_iterator + packet_offset,
+                                     MAP_REGISTER_LOC_LEN);
                        lisp_loc = (const lisp_map_register_loc *) (packet_iterator + packet_offset);
                        loc_ip_pointer = (const u_char *) (lisp_loc + 1);
                        packet_offset += MAP_REGISTER_LOC_LEN;
                        lisp_loc = (const lisp_map_register_loc *) (packet_iterator + packet_offset);
                        loc_ip_pointer = (const u_char *) (lisp_loc + 1);
                        packet_offset += MAP_REGISTER_LOC_LEN;
-                       loc_afi = EXTRACT_BE_16BITS(&lisp_loc->locator_afi);
+                       loc_afi = GET_BE_U_2(lisp_loc->locator_afi);
 
                        if (ndo->ndo_vflag)
 
                        if (ndo->ndo_vflag)
-                               ND_PRINT((ndo, "\n       "));
+                               ND_PRINT("\n       ");
 
                        switch (loc_afi) {
                        case IPv4_AFI:
 
                        switch (loc_afi) {
                        case IPv4_AFI:
-                               ND_TCHECK2(*(packet_iterator + packet_offset), 4);
-                               ND_PRINT((ndo, " LOC %s", ipaddr_string(ndo, loc_ip_pointer)));
+                               ND_TCHECK_4(packet_iterator + packet_offset);
+                               ND_PRINT(" LOC %s", GET_IPADDR_STRING(loc_ip_pointer));
                                packet_offset += 4;
                                break;
                        case IPv6_AFI:
                                packet_offset += 4;
                                break;
                        case IPv6_AFI:
-                               ND_TCHECK2(*(packet_iterator + packet_offset), 16);
-                               ND_PRINT((ndo, " LOC %s", ip6addr_string(ndo, loc_ip_pointer)));
+                               ND_TCHECK_16(packet_iterator + packet_offset);
+                               ND_PRINT(" LOC %s", GET_IP6ADDR_STRING(loc_ip_pointer));
                                packet_offset += 16;
                                break;
                        default:
                                break;
                        }
                        if (ndo->ndo_vflag) {
                                packet_offset += 16;
                                break;
                        default:
                                break;
                        }
                        if (ndo->ndo_vflag) {
-                               ND_PRINT((ndo, "\n          Priority/Weight %u/%u,"
+                               ND_PRINT("\n          Priority/Weight %u/%u,"
                                                " Multicast Priority/Weight %u/%u,",
                                                " Multicast Priority/Weight %u/%u,",
-                                               lisp_loc->priority, lisp_loc->weight,
-                                               lisp_loc->m_priority, lisp_loc->m_weight));
+                                               GET_U_1(lisp_loc->priority),
+                                               GET_U_1(lisp_loc->weight),
+                                               GET_U_1(lisp_loc->m_priority),
+                                               GET_U_1(lisp_loc->m_weight));
                                loc_hdr_flag(ndo,
                                loc_hdr_flag(ndo,
-                                            EXTRACT_BE_16BITS(&lisp_loc->unused_and_flag));
+                                            GET_BE_U_2(lisp_loc->unused_and_flag));
                        }
                }
        }
                        }
                }
        }
@@ -368,33 +369,34 @@ lisp_print(netdissect_options *ndo, const u_char *bp, u_int length)
         * show it as hex data.
         */
        if (xtr_present) {
         * show it as hex data.
         */
        if (xtr_present) {
-               if (!ND_TTEST2(*(packet_iterator + packet_offset), 24))
+               if (!ND_TTEST_LEN(packet_iterator + packet_offset, 24))
                        goto invalid;
                        goto invalid;
-               hex_print_with_offset(ndo, "\n    xTR-ID: ", packet_iterator + packet_offset, 16, 0);
-               ND_PRINT((ndo, "\n    SITE-ID: %" PRIu64,
-                       EXTRACT_BE_64BITS(packet_iterator + packet_offset + 16)));
+               hex_print(ndo, "\n    xTR-ID: ", packet_iterator + packet_offset, 16);
+               ND_PRINT("\n    SITE-ID: %" PRIu64,
+                       GET_BE_U_8(packet_iterator + packet_offset + 16));
        } else {
                /* Check if packet isn't over yet */
                if (packet_iterator + packet_offset < ndo->ndo_snapend) {
        } else {
                /* Check if packet isn't over yet */
                if (packet_iterator + packet_offset < ndo->ndo_snapend) {
-                       hex_print_with_offset(ndo, "\n    Data: ", packet_iterator + packet_offset,
-                               (ndo->ndo_snapend - (packet_iterator + packet_offset)), 0);
+                       hex_print(ndo, "\n    Data: ", packet_iterator + packet_offset,
+                               ND_BYTES_AVAILABLE_AFTER(packet_iterator + packet_offset));
                }
        }
        return;
 trunc:
                }
        }
        return;
 trunc:
-       ND_PRINT((ndo, "\n   %s", tstr));
+       nd_print_trunc(ndo);
        return;
 invalid:
        return;
 invalid:
-       ND_PRINT((ndo, "\n   %s", istr));
-       return;
+       nd_print_invalid(ndo);
 }
 
 }
 
-static inline uint8_t extract_lisp_type(uint8_t lisp_hdr_flags)
+static uint8_t
+extract_lisp_type(uint8_t lisp_hdr_flags)
 {
        return (lisp_hdr_flags) >> TYPE_INDEX;
 }
 
 {
        return (lisp_hdr_flags) >> TYPE_INDEX;
 }
 
-static inline uint8_t is_xtr_data_present(uint8_t type, uint8_t lisp_hdr_flags)
+static uint8_t
+is_xtr_data_present(uint8_t type, uint8_t lisp_hdr_flags)
 {
        uint8_t xtr_present = 0;
 
 {
        uint8_t xtr_present = 0;
 
@@ -408,24 +410,22 @@ static inline uint8_t is_xtr_data_present(uint8_t type, uint8_t lisp_hdr_flags)
 
 static void lisp_hdr_flag(netdissect_options *ndo, const lisp_map_register_hdr *lisp_hdr)
 {
 
 static void lisp_hdr_flag(netdissect_options *ndo, const lisp_map_register_hdr *lisp_hdr)
 {
-       uint8_t type = extract_lisp_type(lisp_hdr->type_and_flag);
+       uint8_t type = extract_lisp_type(GET_U_1(lisp_hdr->type_and_flag));
 
        if (!ndo->ndo_vflag) {
 
        if (!ndo->ndo_vflag) {
-               ND_PRINT((ndo, "%s,", tok2str(lisp_type, "unknown-type-%u", type)));
+               ND_PRINT("%s,", tok2str(lisp_type, "unknown-type-%u", type));
                return;
        } else {
                return;
        } else {
-               ND_PRINT((ndo, "%s,", tok2str(lisp_type, "unknown-type-%u", type)));
+               ND_PRINT("%s,", tok2str(lisp_type, "unknown-type-%u", type));
        }
 
        if (type == LISP_MAP_REGISTER) {
        }
 
        if (type == LISP_MAP_REGISTER) {
-               ND_PRINT((ndo, " flags [%s],", bittok2str(map_register_hdr_flag,
-                        "none", EXTRACT_BE_32BITS(lisp_hdr))));
+               ND_PRINT(" flags [%s],", bittok2str(map_register_hdr_flag,
+                        "none", GET_BE_U_4(lisp_hdr)));
        } else if (type == LISP_MAP_NOTIFY) {
        } else if (type == LISP_MAP_NOTIFY) {
-               ND_PRINT((ndo, " flags [%s],", bittok2str(map_notify_hdr_flag,
-                        "none", EXTRACT_BE_32BITS(lisp_hdr))));
+               ND_PRINT(" flags [%s],", bittok2str(map_notify_hdr_flag,
+                        "none", GET_BE_U_4(lisp_hdr)));
        }
        }
-
-       return;
 }
 
 static void action_flag(netdissect_options *ndo, uint8_t act_auth_inc_res)
 }
 
 static void action_flag(netdissect_options *ndo, uint8_t act_auth_inc_res)
@@ -436,16 +436,16 @@ static void action_flag(netdissect_options *ndo, uint8_t act_auth_inc_res)
        authoritative  = ((act_auth_inc_res >> 4) & 1);
 
        if (authoritative)
        authoritative  = ((act_auth_inc_res >> 4) & 1);
 
        if (authoritative)
-               ND_PRINT((ndo, " Authoritative,"));
+               ND_PRINT(" Authoritative,");
        else
        else
-               ND_PRINT((ndo, " Non-Authoritative,"));
+               ND_PRINT(" Non-Authoritative,");
 
        action = act_auth_inc_res >> 5;
 
        action = act_auth_inc_res >> 5;
-       ND_PRINT((ndo, " %s,", tok2str(lisp_eid_action, "unknown", action)));
+       ND_PRINT(" %s,", tok2str(lisp_eid_action, "unknown", action));
 }
 
 static void loc_hdr_flag(netdissect_options *ndo, uint16_t flag)
 {
 }
 
 static void loc_hdr_flag(netdissect_options *ndo, uint16_t flag)
 {
-       ND_PRINT((ndo, " flags [%s],", bittok2str(lisp_loc_flag, "none", flag)));
+       ND_PRINT(" flags [%s],", bittok2str(lisp_loc_flag, "none", flag));
 }
 
 }
 
[mirror] the TCPdump network dissector