Use nd_ types, add EXTRACT_ calls.

[tcpdump] / print-ldp.c

diff --git a/print-ldp.c b/print-ldp.c
index 1131fe55c47533536ef35cb469c2fc82659c0e82..ac8aecebee81fea5955a46f4331ebdc4649de213 100644 (file)
--- a/print-ldp.c
+++ b/print-ldp.c
@@ -45,10 +45,10 @@
  */
 
 struct ldp_common_header {
-    uint8_t version[2];
-    uint8_t pdu_length[2];
-    uint8_t lsr_id[4];
-    uint8_t label_space[2];
+    nd_uint16_t version;
+    nd_uint16_t pdu_length;
+    nd_ipv4     lsr_id;
+    nd_uint16_t label_space;
 };
 
 #define LDP_VERSION 1
@@ -78,9 +78,9 @@ struct ldp_common_header {
  */
 
 struct ldp_msg_header {
-    uint8_t type[2];
-    uint8_t length[2];
-    uint8_t id[4];
+    nd_uint16_t type;
+    nd_uint16_t length;
+    nd_uint32_t id;
 };
 
 #define        LDP_MASK_MSG_TYPE(x)  ((x)&0x7fff)
@@ -210,7 +210,7 @@ static const struct tok ldp_fec_martini_ifparm_vccv_cv_values[] = {
     { 0, NULL}
 };
 
-static int ldp_pdu_print(netdissect_options *, register const u_char *);
+static int ldp_pdu_print(netdissect_options *, const u_char *);
 
 /*
  * ldp tlv header
@@ -230,16 +230,16 @@ static int ldp_pdu_print(netdissect_options *, register const u_char *);
  */
 
 #define TLV_TCHECK(minlen) \
-    ND_TCHECK2(*tptr, minlen); if (tlv_tlen < minlen) goto badtlv;
+    ND_TCHECK_LEN(tptr, minlen); if (tlv_tlen < minlen) goto badtlv;
 
 static int
 ldp_tlv_print(netdissect_options *ndo,
-              register const u_char *tptr,
+              const u_char *tptr,
               u_short msg_tlen)
 {
     struct ldp_tlv_header {
-        uint8_t type[2];
-        uint8_t length[2];
+        nd_uint16_t type;
+        nd_uint16_t length;
     };
 
     const struct ldp_tlv_header *ldp_tlv_header;
@@ -266,8 +266,8 @@ ldp_tlv_print(netdissect_options *ndo,
                    tlv_type),
            tlv_type,
            tlv_len,
-           LDP_MASK_U_BIT(EXTRACT_BE_U_2(&ldp_tlv_header->type)) ? "continue processing" : "ignore",
-           LDP_MASK_F_BIT(EXTRACT_BE_U_2(&ldp_tlv_header->type)) ? "do" : "don't"));
+           LDP_MASK_U_BIT(EXTRACT_BE_U_2(ldp_tlv_header->type)) ? "continue processing" : "ignore",
+           LDP_MASK_F_BIT(EXTRACT_BE_U_2(ldp_tlv_header->type)) ? "do" : "don't"));
 
     tptr+=sizeof(struct ldp_tlv_header);
 
@@ -304,7 +304,7 @@ ldp_tlv_print(netdissect_options *ndo,
         switch (af) {
         case AFNUM_INET:
            while(tlv_tlen >= sizeof(struct in_addr)) {
-               ND_TCHECK2(*tptr, sizeof(struct in_addr));
+               ND_TCHECK_LEN(tptr, sizeof(struct in_addr));
                ND_PRINT((ndo, " %s", ipaddr_string(ndo, tptr)));
                tlv_tlen-=sizeof(struct in_addr);
                tptr+=sizeof(struct in_addr);
@@ -312,7 +312,7 @@ ldp_tlv_print(netdissect_options *ndo,
             break;
         case AFNUM_INET6:
            while(tlv_tlen >= sizeof(struct in6_addr)) {
-               ND_TCHECK2(*tptr, sizeof(struct in6_addr));
+               ND_TCHECK_LEN(tptr, sizeof(struct in6_addr));
                ND_PRINT((ndo, " %s", ip6addr_string(ndo, tptr)));
                tlv_tlen-=sizeof(struct in6_addr);
                tptr+=sizeof(struct in6_addr);
@@ -335,7 +335,7 @@ ldp_tlv_print(netdissect_options *ndo,
 
     case LDP_TLV_FEC:
         TLV_TCHECK(1);
-        fec_type = *tptr;
+        fec_type = EXTRACT_U_1(tptr);
        ND_PRINT((ndo, "\n\t      %s FEC (0x%02x)",
               tok2str(ldp_fec_values, "Unknown", fec_type),
               fec_type));
@@ -421,7 +421,7 @@ ldp_tlv_print(netdissect_options *ndo,
             TLV_TCHECK(vc_info_len);
 
             while (vc_info_len > 2) {
-                vc_info_tlv_type = *tptr;
+                vc_info_tlv_type = EXTRACT_U_1(tptr);
                 vc_info_tlv_len = EXTRACT_U_1(tptr + 1);
                 if (vc_info_tlv_len < 2)
                     break;
@@ -544,7 +544,7 @@ badtlv:
 
 void
 ldp_print(netdissect_options *ndo,
-          register const u_char *pptr, register u_int len)
+          const u_char *pptr, u_int len)
 {
     int processed;
     while (len > (sizeof(struct ldp_common_header) + sizeof(struct ldp_msg_header))) {
@@ -558,7 +558,7 @@ ldp_print(netdissect_options *ndo,
 
 static int
 ldp_pdu_print(netdissect_options *ndo,
-              register const u_char *pptr)
+              const u_char *pptr)
 {
     const struct ldp_common_header *ldp_com_header;
     const struct ldp_msg_header *ldp_msg_header;
@@ -573,14 +573,14 @@ ldp_pdu_print(netdissect_options *ndo,
     /*
      * Sanity checking of the header.
      */
-    if (EXTRACT_BE_U_2(&ldp_com_header->version) != LDP_VERSION) {
+    if (EXTRACT_BE_U_2(ldp_com_header->version) != LDP_VERSION) {
        ND_PRINT((ndo, "%sLDP version %u packet not supported",
                (ndo->ndo_vflag < 1) ? "" : "\n\t",
-               EXTRACT_BE_U_2(&ldp_com_header->version)));
+               EXTRACT_BE_U_2(ldp_com_header->version)));
        return 0;
     }
 
-    pdu_len = EXTRACT_BE_U_2(&ldp_com_header->pdu_length);
+    pdu_len = EXTRACT_BE_U_2(ldp_com_header->pdu_length);
     if (pdu_len < sizeof(struct ldp_common_header)-4) {
         /* length too short */
         ND_PRINT((ndo, "%sLDP, pdu-length: %u (too short, < %u)",
@@ -594,7 +594,7 @@ ldp_pdu_print(netdissect_options *ndo,
     ND_PRINT((ndo, "%sLDP, Label-Space-ID: %s:%u, pdu-length: %u",
            (ndo->ndo_vflag < 1) ? "" : "\n\t",
            ipaddr_string(ndo, &ldp_com_header->lsr_id),
-           EXTRACT_BE_U_2(&ldp_com_header->label_space),
+           EXTRACT_BE_U_2(ldp_com_header->label_space),
            pdu_len));
 
     /* bail out if non-verbose */
@@ -607,7 +607,7 @@ ldp_pdu_print(netdissect_options *ndo,
 
     while(tlen>0) {
         /* did we capture enough for fully decoding the msg header ? */
-        ND_TCHECK2(*tptr, sizeof(struct ldp_msg_header));
+        ND_TCHECK_LEN(tptr, sizeof(struct ldp_msg_header));
 
         ldp_msg_header = (const struct ldp_msg_header *)tptr;
         msg_len=EXTRACT_BE_U_2(ldp_msg_header->length);
@@ -633,14 +633,14 @@ ldp_pdu_print(netdissect_options *ndo,
                        msg_type),
                msg_type,
                msg_len,
-               EXTRACT_BE_U_4(&ldp_msg_header->id),
-               LDP_MASK_U_BIT(EXTRACT_BE_U_2(&ldp_msg_header->type)) ? "continue processing" : "ignore"));
+               EXTRACT_BE_U_4(ldp_msg_header->id),
+               LDP_MASK_U_BIT(EXTRACT_BE_U_2(ldp_msg_header->type)) ? "continue processing" : "ignore"));
 
         msg_tptr=tptr+sizeof(struct ldp_msg_header);
         msg_tlen=msg_len-(sizeof(struct ldp_msg_header)-4); /* Type & Length fields not included */
 
         /* did we capture enough for fully decoding the message ? */
-        ND_TCHECK2(*tptr, msg_len);
+        ND_TCHECK_LEN(tptr, msg_len);
         hexdump=FALSE;
 
         switch(msg_type) {