1 files changed, 81 insertions, 77 deletions

diff --git a/print-lisp.c b/print-lisp.c
index 47afe503596c..756fff0ffc5a 100644
--- a/print-lisp.c
+++ b/print-lisp.c
@@ -95,13 +95,11 @@
  */
 
 #ifdef HAVE_CONFIG_H
-#include "config.h"
+#include <config.h>
 #endif
 
-#include <netdissect-stdinc.h>
-#include <netdissect.h>
-#include <string.h>
-#include <stdlib.h>
+#include "netdissect-stdinc.h"
+#include "netdissect.h"
 
 #include "ip.h"
 #include "ip6.h"
@@ -109,7 +107,6 @@
 #include "extract.h"
 #include "addrtoname.h"
 
-static const char tstr[] = " [|LISP]";
 
 #define IPv4_AFI			1
 #define IPv6_AFI			2
@@ -205,8 +202,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 reserved_version_hi;
-	nd_uint8_t version_low;
+	nd_uint16_t reserved_and_version;
 	nd_uint16_t eid_prefix_afi;
 } lisp_map_register_eid;
 
@@ -223,14 +219,16 @@ typedef struct 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);
 
-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;
@@ -249,33 +247,35 @@ void 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;
 
+	ndo->ndo_protocol = "lisp";
 	/* 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 */
-	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 */
-	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 */
-	auth_data_len = EXTRACT_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;
-	record_count = lisp_hdr->record_count;
+	record_count = GET_U_1(lisp_hdr->record_count);
 
 	if (ndo->ndo_vflag) {
-		key_id = EXTRACT_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 {
-		ND_PRINT((ndo, " %u record(s),", record_count));
+		ND_PRINT(" %u record(s),", record_count);
 	}
 	packet_offset += auth_data_len;
 
@@ -283,37 +283,37 @@ void lisp_print(netdissect_options *ndo, const u_char *bp, u_int length)
 		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;
-		mask_len = lisp_eid->eid_prefix_mask_length;
-		eid_afi = EXTRACT_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) {
-			ttl = EXTRACT_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:
-			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:
-			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:
@@ -324,38 +324,43 @@ void lisp_print(netdissect_options *ndo, const u_char *bp, u_int length)
 			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;
-			loc_afi = EXTRACT_16BITS(&lisp_loc->locator_afi);
+			loc_afi = GET_BE_U_2(lisp_loc->locator_afi);
 
 			if (ndo->ndo_vflag)
-				ND_PRINT((ndo, "\n       "));
+				ND_PRINT("\n       ");
 
 			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:
-				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) {
-				ND_PRINT((ndo, "\n          Priority/Weight %u/%u,"
+				ND_PRINT("\n          Priority/Weight %u/%u,"
 						" Multicast Priority/Weight %u/%u,",
-						lisp_loc->priority, lisp_loc->weight,
-						lisp_loc->m_priority, lisp_loc->m_weight));
-				loc_hdr_flag(ndo, EXTRACT_16BITS(&lisp_loc->unused_and_flag));
+						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,
+					     GET_BE_U_2(lisp_loc->unused_and_flag));
 			}
 		}
 	}
@@ -366,33 +371,34 @@ void lisp_print(netdissect_options *ndo, const u_char *bp, u_int length)
 	 * 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;
-		hex_print_with_offset(ndo, "\n    xTR-ID: ", packet_iterator + packet_offset, 16, 0);
-		ND_PRINT((ndo, "\n    SITE-ID: %" PRIu64,
-			EXTRACT_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) {
-			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:
-	ND_PRINT((ndo, "\n   %s", tstr));
+	nd_print_trunc(ndo);
 	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;
 }
 
-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;
 
@@ -406,24 +412,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)
 {
-	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) {
-		ND_PRINT((ndo, "%s,", tok2str(lisp_type, "unknown-type-%u", type)));
+		ND_PRINT("%s,", tok2str(lisp_type, "unknown-type-%u", type));
 		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) {
-		ND_PRINT((ndo, " flags [%s],", bittok2str(map_register_hdr_flag,
-			 "none", EXTRACT_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) {
-		ND_PRINT((ndo, " flags [%s],", bittok2str(map_notify_hdr_flag,
-			 "none", EXTRACT_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)
@@ -434,16 +438,16 @@ static void action_flag(netdissect_options *ndo, uint8_t act_auth_inc_res)
 	authoritative  = ((act_auth_inc_res >> 4) & 1);
 
 	if (authoritative)
-		ND_PRINT((ndo, " Authoritative,"));
+		ND_PRINT(" Authoritative,");
 	else
-		ND_PRINT((ndo, " Non-Authoritative,"));
+		ND_PRINT(" Non-Authoritative,");
 
 	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)
 {
-	ND_PRINT((ndo, " flags [%s],", bittok2str(lisp_loc_flag, "none", flag)));
+	ND_PRINT(" flags [%s],", bittok2str(lisp_loc_flag, "none", flag));
 }