OpenFlow: Have a function for each message type.

[tcpdump] / print-pgm.c

diff --git a/print-pgm.c b/print-pgm.c
index de33a9af7ffac9c6b096ae8ffa4488e38505fcef..ccb0b46afef9982c4e1851063baa355f101e8b05 100644 (file)
--- a/print-pgm.c
+++ b/print-pgm.c
@@ -16,10 +16,10 @@
 /* \summary: Pragmatic General Multicast (PGM) printer */
 
 #ifdef HAVE_CONFIG_H
 /* \summary: Pragmatic General Multicast (PGM) printer */
 
 #ifdef HAVE_CONFIG_H

-#include "config.h"
+#include <config.h>

 #endif
 
 #endif
 

-#include <netdissect-stdinc.h>
+#include "netdissect-stdinc.h"

 
 #include "netdissect.h"
 #include "extract.h"
 
 #include "netdissect.h"
 #include "extract.h"


@@ -74,17 +74,17 @@ struct pgm_ack {
 struct pgm_poll {
     nd_uint32_t        pgmp_seq;
     nd_uint16_t        pgmp_round;
 struct pgm_poll {
     nd_uint32_t        pgmp_seq;
     nd_uint16_t        pgmp_round;

+    nd_uint16_t        pgmp_subtype;
+    nd_uint16_t        pgmp_nla_afi;

     nd_uint16_t        pgmp_reserved;
     nd_uint16_t        pgmp_reserved;

+    /* ... uint8_t     pgmp_nla[0]; */

     /* ... options */
 };
 
 struct pgm_polr {
     nd_uint32_t        pgmp_seq;
     nd_uint16_t        pgmp_round;
     /* ... options */
 };
 
 struct pgm_polr {
     nd_uint32_t        pgmp_seq;
     nd_uint16_t        pgmp_round;

-    nd_uint16_t        pgmp_subtype;
-    nd_uint16_t        pgmp_nla_afi;

     nd_uint16_t        pgmp_reserved;
     nd_uint16_t        pgmp_reserved;

-    /* ... uint8_t     pgmp_nla[0]; */

     /* ... options */
 };
 
     /* ... options */
 };
 


@@ -149,7 +149,6 @@ pgm_print(netdissect_options *ndo,
 {
        const struct pgm_header *pgm;
        const struct ip *ip;
 {
        const struct pgm_header *pgm;
        const struct ip *ip;

-       char ch;

        uint8_t pgm_type_val;
        uint16_t sport, dport;
        u_int nla_afnum;
        uint8_t pgm_type_val;
        uint16_t sport, dport;
        u_int nla_afnum;


@@ -158,68 +157,69 @@ pgm_print(netdissect_options *ndo,
        uint8_t opt_type, opt_len;
        uint32_t seq, opts_len, len, offset;
 
        uint8_t opt_type, opt_len;
        uint32_t seq, opts_len, len, offset;
 

+       ndo->ndo_protocol = "pgm";

        pgm = (const struct pgm_header *)bp;
        ip = (const struct ip *)bp2;
        if (IP_V(ip) == 6)
                ip6 = (const struct ip6_hdr *)bp2;
        else
                ip6 = NULL;
        pgm = (const struct pgm_header *)bp;
        ip = (const struct ip *)bp2;
        if (IP_V(ip) == 6)
                ip6 = (const struct ip6_hdr *)bp2;
        else
                ip6 = NULL;

-       ch = '\0';

        if (!ND_TTEST_2(pgm->pgm_dport)) {
                if (ip6) {
        if (!ND_TTEST_2(pgm->pgm_dport)) {
                if (ip6) {

-                       ND_PRINT((ndo, "%s > %s: [|pgm]",
-                               ip6addr_string(ndo, &ip6->ip6_src),
-                               ip6addr_string(ndo, &ip6->ip6_dst)));
+                       ND_PRINT("%s > %s:",
+                               GET_IP6ADDR_STRING(ip6->ip6_src),
+                               GET_IP6ADDR_STRING(ip6->ip6_dst));

                } else {
                } else {

-                       ND_PRINT((ndo, "%s > %s: [|pgm]",
-                               ipaddr_string(ndo, &ip->ip_src),
-                               ipaddr_string(ndo, &ip->ip_dst)));
+                       ND_PRINT("%s > %s:",
+                               GET_IPADDR_STRING(ip->ip_src),
+                               GET_IPADDR_STRING(ip->ip_dst));

                }
                }

+               nd_print_trunc(ndo);

                return;
        }
 
                return;
        }
 

-       sport = EXTRACT_BE_U_2(pgm->pgm_sport);
-       dport = EXTRACT_BE_U_2(pgm->pgm_dport);
+       sport = GET_BE_U_2(pgm->pgm_sport);
+       dport = GET_BE_U_2(pgm->pgm_dport);

 
        if (ip6) {
 
        if (ip6) {

-               if (EXTRACT_U_1(ip6->ip6_nxt) == IPPROTO_PGM) {
-                       ND_PRINT((ndo, "%s.%s > %s.%s: ",
-                               ip6addr_string(ndo, &ip6->ip6_src),
+               if (GET_U_1(ip6->ip6_nxt) == IPPROTO_PGM) {
+                       ND_PRINT("%s.%s > %s.%s: ",
+                               GET_IP6ADDR_STRING(ip6->ip6_src),

                                tcpport_string(ndo, sport),
                                tcpport_string(ndo, sport),

-                               ip6addr_string(ndo, &ip6->ip6_dst),
-                               tcpport_string(ndo, dport)));
+                               GET_IP6ADDR_STRING(ip6->ip6_dst),
+                               tcpport_string(ndo, dport));

                } else {
                } else {

-                       ND_PRINT((ndo, "%s > %s: ",
-                               tcpport_string(ndo, sport), tcpport_string(ndo, dport)));
+                       ND_PRINT("%s > %s: ",
+                               tcpport_string(ndo, sport), tcpport_string(ndo, dport));

                }
        } else {
                }
        } else {

-               if (EXTRACT_U_1(ip->ip_p) == IPPROTO_PGM) {
-                       ND_PRINT((ndo, "%s.%s > %s.%s: ",
-                               ipaddr_string(ndo, &ip->ip_src),
+               if (GET_U_1(ip->ip_p) == IPPROTO_PGM) {
+                       ND_PRINT("%s.%s > %s.%s: ",
+                               GET_IPADDR_STRING(ip->ip_src),

                                tcpport_string(ndo, sport),
                                tcpport_string(ndo, sport),

-                               ipaddr_string(ndo, &ip->ip_dst),
-                               tcpport_string(ndo, dport)));
+                               GET_IPADDR_STRING(ip->ip_dst),
+                               tcpport_string(ndo, dport));

                } else {
                } else {

-                       ND_PRINT((ndo, "%s > %s: ",
-                               tcpport_string(ndo, sport), tcpport_string(ndo, dport)));
+                       ND_PRINT("%s > %s: ",
+                               tcpport_string(ndo, sport), tcpport_string(ndo, dport));

                }
        }
 
        ND_TCHECK_SIZE(pgm);
 
                }
        }
 
        ND_TCHECK_SIZE(pgm);
 

-        ND_PRINT((ndo, "PGM, length %u", EXTRACT_BE_U_2(pgm->pgm_length)));
+        ND_PRINT("PGM, length %u", GET_BE_U_2(pgm->pgm_length));

 
         if (!ndo->ndo_vflag)
             return;
 
 
         if (!ndo->ndo_vflag)
             return;
 

-       pgm_type_val = EXTRACT_U_1(pgm->pgm_type);
-       ND_PRINT((ndo, " 0x%02x%02x%02x%02x%02x%02x ",
+       pgm_type_val = GET_U_1(pgm->pgm_type);
+       ND_PRINT(" 0x%02x%02x%02x%02x%02x%02x ",

                     pgm->pgm_gsid[0],
                      pgm->pgm_gsid[1],
                      pgm->pgm_gsid[2],
                     pgm->pgm_gsid[3],
                      pgm->pgm_gsid[4],
                     pgm->pgm_gsid[0],
                      pgm->pgm_gsid[1],
                      pgm->pgm_gsid[2],
                     pgm->pgm_gsid[3],
                      pgm->pgm_gsid[4],

-                     pgm->pgm_gsid[5]));
+                     pgm->pgm_gsid[5]);

        switch (pgm_type_val) {
        case PGM_SPM: {
            const struct pgm_spm *spm;
        switch (pgm_type_val) {
        case PGM_SPM: {
            const struct pgm_spm *spm;


@@ -228,80 +228,78 @@ pgm_print(netdissect_options *ndo,
            ND_TCHECK_SIZE(spm);
            bp = (const u_char *) (spm + 1);
 
            ND_TCHECK_SIZE(spm);
            bp = (const u_char *) (spm + 1);
 

-           switch (EXTRACT_BE_U_2(spm->pgms_nla_afi)) {
+           switch (GET_BE_U_2(spm->pgms_nla_afi)) {

            case AFNUM_INET:
            case AFNUM_INET:

-               ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv4));

                addrtostr(bp, nla_buf, sizeof(nla_buf));
                addrtostr(bp, nla_buf, sizeof(nla_buf));

-               bp += sizeof(struct in_addr);
+               bp += sizeof(nd_ipv4);

                break;
            case AFNUM_INET6:
                break;
            case AFNUM_INET6:

-               ND_TCHECK_LEN(bp, sizeof(struct in6_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv6));

                addrtostr6(bp, nla_buf, sizeof(nla_buf));
                addrtostr6(bp, nla_buf, sizeof(nla_buf));

-               bp += sizeof(struct in6_addr);
+               bp += sizeof(nd_ipv6);

                break;
            default:
                goto trunc;
                break;
            }
 
                break;
            default:
                goto trunc;
                break;
            }
 

-           ND_PRINT((ndo, "SPM seq %u trail %u lead %u nla %s",
-                        EXTRACT_BE_U_4(spm->pgms_seq),
-                        EXTRACT_BE_U_4(spm->pgms_trailseq),
-                        EXTRACT_BE_U_4(spm->pgms_leadseq),
-                        nla_buf));
+           ND_PRINT("SPM seq %u trail %u lead %u nla %s",
+                        GET_BE_U_4(spm->pgms_seq),
+                        GET_BE_U_4(spm->pgms_trailseq),
+                        GET_BE_U_4(spm->pgms_leadseq),
+                        nla_buf);

            break;
        }
 
        case PGM_POLL: {
            break;
        }
 
        case PGM_POLL: {

-           const struct pgm_poll *poll_msg;
-
-           poll_msg = (const struct pgm_poll *)(pgm + 1);
-           ND_TCHECK_SIZE(poll_msg);
-           ND_PRINT((ndo, "POLL seq %u round %u",
-                        EXTRACT_BE_U_4(poll_msg->pgmp_seq),
-                        EXTRACT_BE_U_2(poll_msg->pgmp_round)));
-           bp = (const u_char *) (poll_msg + 1);
-           break;
-       }
-       case PGM_POLR: {
-           const struct pgm_polr *polr;
+           const struct pgm_poll *pgm_poll;

            uint32_t ivl, rnd, mask;
 
            uint32_t ivl, rnd, mask;
 

-           polr = (const struct pgm_polr *)(pgm + 1);
-           ND_TCHECK_SIZE(polr);
-           bp = (const u_char *) (polr + 1);
+           pgm_poll = (const struct pgm_poll *)(pgm + 1);
+           ND_TCHECK_SIZE(pgm_poll);
+           bp = (const u_char *) (pgm_poll + 1);

 
 

-           switch (EXTRACT_BE_U_2(polr->pgmp_nla_afi)) {
+           switch (GET_BE_U_2(pgm_poll->pgmp_nla_afi)) {

            case AFNUM_INET:
            case AFNUM_INET:

-               ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv4));

                addrtostr(bp, nla_buf, sizeof(nla_buf));
                addrtostr(bp, nla_buf, sizeof(nla_buf));

-               bp += sizeof(struct in_addr);
+               bp += sizeof(nd_ipv4);

                break;
            case AFNUM_INET6:
                break;
            case AFNUM_INET6:

-               ND_TCHECK_LEN(bp, sizeof(struct in6_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv6));

                addrtostr6(bp, nla_buf, sizeof(nla_buf));
                addrtostr6(bp, nla_buf, sizeof(nla_buf));

-               bp += sizeof(struct in6_addr);
+               bp += sizeof(nd_ipv6);

                break;
            default:
                goto trunc;
                break;
            }
 
                break;
            default:
                goto trunc;
                break;
            }
 

-           ND_TCHECK_LEN(bp, sizeof(uint32_t));
-           ivl = EXTRACT_BE_U_4(bp);
+           ivl = GET_BE_U_4(bp);

            bp += sizeof(uint32_t);
 
            bp += sizeof(uint32_t);
 

-           ND_TCHECK_LEN(bp, sizeof(uint32_t));
-           rnd = EXTRACT_BE_U_4(bp);
+           rnd = GET_BE_U_4(bp);

            bp += sizeof(uint32_t);
 
            bp += sizeof(uint32_t);
 

-           ND_TCHECK_LEN(bp, sizeof(uint32_t));
-           mask = EXTRACT_BE_U_4(bp);
+           mask = GET_BE_U_4(bp);

            bp += sizeof(uint32_t);
 
            bp += sizeof(uint32_t);
 

-           ND_PRINT((ndo, "POLR seq %u round %u nla %s ivl %u rnd 0x%08x "
-                        "mask 0x%08x", EXTRACT_BE_U_4(polr->pgmp_seq),
-                        EXTRACT_BE_U_2(polr->pgmp_round), nla_buf, ivl, rnd, mask));
+           ND_PRINT("POLL seq %u round %u nla %s ivl %u rnd 0x%08x "
+                        "mask 0x%08x", GET_BE_U_4(pgm_poll->pgmp_seq),
+                        GET_BE_U_2(pgm_poll->pgmp_round), nla_buf, ivl, rnd,
+                        mask);
+           break;
+       }
+       case PGM_POLR: {
+           const struct pgm_polr *polr_msg;
+
+           polr_msg = (const struct pgm_polr *)(pgm + 1);
+           ND_TCHECK_SIZE(polr_msg);
+           ND_PRINT("POLR seq %u round %u",
+                        GET_BE_U_4(polr_msg->pgmp_seq),
+                        GET_BE_U_2(polr_msg->pgmp_round));
+           bp = (const u_char *) (polr_msg + 1);

            break;
        }
        case PGM_ODATA: {
            break;
        }
        case PGM_ODATA: {


@@ -309,9 +307,9 @@ pgm_print(netdissect_options *ndo,
 
            odata = (const struct pgm_data *)(pgm + 1);
            ND_TCHECK_SIZE(odata);
 
            odata = (const struct pgm_data *)(pgm + 1);
            ND_TCHECK_SIZE(odata);

-           ND_PRINT((ndo, "ODATA trail %u seq %u",
-                        EXTRACT_BE_U_4(odata->pgmd_trailseq),
-                        EXTRACT_BE_U_4(odata->pgmd_seq)));
+           ND_PRINT("ODATA trail %u seq %u",
+                        GET_BE_U_4(odata->pgmd_trailseq),
+                        GET_BE_U_4(odata->pgmd_seq));

            bp = (const u_char *) (odata + 1);
            break;
        }
            bp = (const u_char *) (odata + 1);
            break;
        }


@@ -321,9 +319,9 @@ pgm_print(netdissect_options *ndo,
 
            rdata = (const struct pgm_data *)(pgm + 1);
            ND_TCHECK_SIZE(rdata);
 
            rdata = (const struct pgm_data *)(pgm + 1);
            ND_TCHECK_SIZE(rdata);

-           ND_PRINT((ndo, "RDATA trail %u seq %u",
-                        EXTRACT_BE_U_4(rdata->pgmd_trailseq),
-                        EXTRACT_BE_U_4(rdata->pgmd_seq)));
+           ND_PRINT("RDATA trail %u seq %u",
+                        GET_BE_U_4(rdata->pgmd_trailseq),
+                        GET_BE_U_4(rdata->pgmd_seq));

            bp = (const u_char *) (rdata + 1);
            break;
        }
            bp = (const u_char *) (rdata + 1);
            break;
        }


@@ -342,16 +340,16 @@ pgm_print(netdissect_options *ndo,
             * Skip past the source, saving info along the way
             * and stopping if we don't have enough.
             */
             * Skip past the source, saving info along the way
             * and stopping if we don't have enough.
             */

-           switch (EXTRACT_BE_U_2(nak->pgmn_source_afi)) {
+           switch (GET_BE_U_2(nak->pgmn_source_afi)) {

            case AFNUM_INET:
            case AFNUM_INET:

-               ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv4));

                addrtostr(bp, source_buf, sizeof(source_buf));
                addrtostr(bp, source_buf, sizeof(source_buf));

-               bp += sizeof(struct in_addr);
+               bp += sizeof(nd_ipv4);

                break;
            case AFNUM_INET6:
                break;
            case AFNUM_INET6:

-               ND_TCHECK_LEN(bp, sizeof(struct in6_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv6));

                addrtostr6(bp, source_buf, sizeof(source_buf));
                addrtostr6(bp, source_buf, sizeof(source_buf));

-               bp += sizeof(struct in6_addr);
+               bp += sizeof(nd_ipv6);

                break;
            default:
                goto trunc;
                break;
            default:
                goto trunc;


@@ -363,17 +361,16 @@ pgm_print(netdissect_options *ndo,
             * and stopping if we don't have enough.
             */
            bp += (2 * sizeof(uint16_t));
             * and stopping if we don't have enough.
             */
            bp += (2 * sizeof(uint16_t));

-           ND_TCHECK_2(bp);
-           switch (EXTRACT_BE_U_2(bp)) {
+           switch (GET_BE_U_2(bp)) {

            case AFNUM_INET:
            case AFNUM_INET:

-               ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv4));

                addrtostr(bp, group_buf, sizeof(group_buf));
                addrtostr(bp, group_buf, sizeof(group_buf));

-               bp += sizeof(struct in_addr);
+               bp += sizeof(nd_ipv4);

                break;
            case AFNUM_INET6:
                break;
            case AFNUM_INET6:

-               ND_TCHECK_LEN(bp, sizeof(struct in6_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv6));

                addrtostr6(bp, group_buf, sizeof(group_buf));
                addrtostr6(bp, group_buf, sizeof(group_buf));

-               bp += sizeof(struct in6_addr);
+               bp += sizeof(nd_ipv6);

                break;
            default:
                goto trunc;
                break;
            default:
                goto trunc;


@@ -385,19 +382,19 @@ pgm_print(netdissect_options *ndo,
             */
            switch (pgm_type_val) {
                case PGM_NAK:
             */
            switch (pgm_type_val) {
                case PGM_NAK:

-                   ND_PRINT((ndo, "NAK "));
+                   ND_PRINT("NAK ");

                    break;
                case PGM_NULLNAK:
                    break;
                case PGM_NULLNAK:

-                   ND_PRINT((ndo, "NNAK "));
+                   ND_PRINT("NNAK ");

                    break;
                case PGM_NCF:
                    break;
                case PGM_NCF:

-                   ND_PRINT((ndo, "NCF "));
+                   ND_PRINT("NCF ");

                    break;
                default:
                     break;
            }
                    break;
                default:
                     break;
            }

-           ND_PRINT((ndo, "(%s -> %s), seq %u",
-                        source_buf, group_buf, EXTRACT_BE_U_4(nak->pgmn_seq)));
+           ND_PRINT("(%s -> %s), seq %u",
+                        source_buf, group_buf, GET_BE_U_4(nak->pgmn_seq));

            break;
        }
 
            break;
        }
 


@@ -406,92 +403,82 @@ pgm_print(netdissect_options *ndo,
 
            ack = (const struct pgm_ack *)(pgm + 1);
            ND_TCHECK_SIZE(ack);
 
            ack = (const struct pgm_ack *)(pgm + 1);
            ND_TCHECK_SIZE(ack);

-           ND_PRINT((ndo, "ACK seq %u",
-                        EXTRACT_BE_U_4(ack->pgma_rx_max_seq)));
+           ND_PRINT("ACK seq %u",
+                        GET_BE_U_4(ack->pgma_rx_max_seq));

            bp = (const u_char *) (ack + 1);
            break;
        }
 
        case PGM_SPMR:
            bp = (const u_char *) (ack + 1);
            break;
        }
 
        case PGM_SPMR:

-           ND_PRINT((ndo, "SPMR"));
+           ND_PRINT("SPMR");

            break;
 
        default:
            break;
 
        default:

-           ND_PRINT((ndo, "UNKNOWN type 0x%02x", pgm_type_val));
+           ND_PRINT("UNKNOWN type 0x%02x", pgm_type_val);

            break;
 
        }
            break;
 
        }

-       if (EXTRACT_U_1(pgm->pgm_options) & PGM_OPT_BIT_PRESENT) {
+       if (GET_U_1(pgm->pgm_options) & PGM_OPT_BIT_PRESENT) {

 
            /*
             * make sure there's enough for the first option header
             */
 
            /*
             * make sure there's enough for the first option header
             */

-           if (!ND_TTEST_LEN(bp, PGM_MIN_OPT_LEN)) {
-               ND_PRINT((ndo, "[|OPT]"));
-               return;
-           }
+           ND_TCHECK_LEN(bp, PGM_MIN_OPT_LEN);

 
            /*
             * That option header MUST be an OPT_LENGTH option
             * (see the first paragraph of section 9.1 in RFC 3208).
             */
 
            /*
             * That option header MUST be an OPT_LENGTH option
             * (see the first paragraph of section 9.1 in RFC 3208).
             */

-           opt_type = EXTRACT_U_1(bp);
+           opt_type = GET_U_1(bp);

            bp++;
            if ((opt_type & PGM_OPT_MASK) != PGM_OPT_LENGTH) {
            bp++;
            if ((opt_type & PGM_OPT_MASK) != PGM_OPT_LENGTH) {

-               ND_PRINT((ndo, "[First option bad, should be PGM_OPT_LENGTH, is %u]", opt_type & PGM_OPT_MASK));
+               ND_PRINT("[First option bad, should be PGM_OPT_LENGTH, is %u]", opt_type & PGM_OPT_MASK);

                return;
            }
                return;
            }

-           opt_len = EXTRACT_U_1(bp);
+           opt_len = GET_U_1(bp);

            bp++;
            if (opt_len != 4) {
            bp++;
            if (opt_len != 4) {

-               ND_PRINT((ndo, "[Bad OPT_LENGTH option, length %u != 4]", opt_len));
+               ND_PRINT("[Bad OPT_LENGTH option, length %u != 4]", opt_len);

                return;
            }
                return;
            }

-           opts_len = EXTRACT_BE_U_2(bp);
+           opts_len = GET_BE_U_2(bp);

            bp += sizeof(uint16_t);
            if (opts_len < 4) {
            bp += sizeof(uint16_t);
            if (opts_len < 4) {

-               ND_PRINT((ndo, "[Bad total option length %u < 4]", opts_len));
+               ND_PRINT("[Bad total option length %u < 4]", opts_len);

                return;
            }
                return;
            }

-           ND_PRINT((ndo, " OPTS LEN %u", opts_len));
+           ND_PRINT(" OPTS LEN %u", opts_len);

            opts_len -= 4;
 
            while (opts_len) {
                if (opts_len < PGM_MIN_OPT_LEN) {
            opts_len -= 4;
 
            while (opts_len) {
                if (opts_len < PGM_MIN_OPT_LEN) {

-                   ND_PRINT((ndo, "[Total option length leaves no room for final option]"));
+                   ND_PRINT("[Total option length leaves no room for final option]");

                    return;
                }
                    return;
                }

-               if (!ND_TTEST_2(bp)) {
-                   ND_PRINT((ndo, " [|OPT]"));
-                   return;
-               }
-               opt_type = EXTRACT_U_1(bp);
+               opt_type = GET_U_1(bp);

                bp++;
                bp++;

-               opt_len = EXTRACT_U_1(bp);
+               opt_len = GET_U_1(bp);

                bp++;
                if (opt_len < PGM_MIN_OPT_LEN) {
                bp++;
                if (opt_len < PGM_MIN_OPT_LEN) {

-                   ND_PRINT((ndo, "[Bad option, length %u < %u]", opt_len,
-                       PGM_MIN_OPT_LEN));
+                   ND_PRINT("[Bad option, length %u < %u]", opt_len,
+                       PGM_MIN_OPT_LEN);

                    break;
                }
                if (opts_len < opt_len) {
                    break;
                }
                if (opts_len < opt_len) {

-                   ND_PRINT((ndo, "[Total option length leaves no room for final option]"));
-                   return;
-               }
-               if (!ND_TTEST_LEN(bp, opt_len - 2)) {
-                   ND_PRINT((ndo, " [|OPT]"));
+                   ND_PRINT("[Total option length leaves no room for final option]");

                    return;
                }
                    return;
                }

+               ND_TCHECK_LEN(bp, opt_len - 2);

 
                switch (opt_type & PGM_OPT_MASK) {
                case PGM_OPT_LENGTH:
 #define PGM_OPT_LENGTH_LEN     (2+2)
                    if (opt_len != PGM_OPT_LENGTH_LEN) {
 
                switch (opt_type & PGM_OPT_MASK) {
                case PGM_OPT_LENGTH:
 #define PGM_OPT_LENGTH_LEN     (2+2)
                    if (opt_len != PGM_OPT_LENGTH_LEN) {

-                       ND_PRINT((ndo, "[Bad OPT_LENGTH option, length %u != %u]",
-                           opt_len, PGM_OPT_LENGTH_LEN));
+                       ND_PRINT("[Bad OPT_LENGTH option, length %u != %u]",
+                           opt_len, PGM_OPT_LENGTH_LEN);

                        return;
                    }
                        return;
                    }

-                   ND_PRINT((ndo, " OPTS LEN (extra?) %u", EXTRACT_BE_U_2(bp)));
+                   ND_PRINT(" OPTS LEN (extra?) %u", GET_BE_U_2(bp));

                    bp += 2;
                    opts_len -= PGM_OPT_LENGTH_LEN;
                    break;
                    bp += 2;
                    opts_len -= PGM_OPT_LENGTH_LEN;
                    break;


@@ -499,32 +486,31 @@ pgm_print(netdissect_options *ndo,
                case PGM_OPT_FRAGMENT:
 #define PGM_OPT_FRAGMENT_LEN   (2+2+4+4+4)
                    if (opt_len != PGM_OPT_FRAGMENT_LEN) {
                case PGM_OPT_FRAGMENT:
 #define PGM_OPT_FRAGMENT_LEN   (2+2+4+4+4)
                    if (opt_len != PGM_OPT_FRAGMENT_LEN) {

-                       ND_PRINT((ndo, "[Bad OPT_FRAGMENT option, length %u != %u]",
-                           opt_len, PGM_OPT_FRAGMENT_LEN));
+                       ND_PRINT("[Bad OPT_FRAGMENT option, length %u != %u]",
+                           opt_len, PGM_OPT_FRAGMENT_LEN);

                        return;
                    }
                    bp += 2;
                        return;
                    }
                    bp += 2;

-                   seq = EXTRACT_BE_U_4(bp);
+                   seq = GET_BE_U_4(bp);

                    bp += 4;
                    bp += 4;

-                   offset = EXTRACT_BE_U_4(bp);
+                   offset = GET_BE_U_4(bp);

                    bp += 4;
                    bp += 4;

-                   len = EXTRACT_BE_U_4(bp);
+                   len = GET_BE_U_4(bp);

                    bp += 4;
                    bp += 4;

-                   ND_PRINT((ndo, " FRAG seq %u off %u len %u", seq, offset, len));
+                   ND_PRINT(" FRAG seq %u off %u len %u", seq, offset, len);

                    opts_len -= PGM_OPT_FRAGMENT_LEN;
                    break;
 
                case PGM_OPT_NAK_LIST:
                    bp += 2;
                    opt_len -= 4;       /* option header */
                    opts_len -= PGM_OPT_FRAGMENT_LEN;
                    break;
 
                case PGM_OPT_NAK_LIST:
                    bp += 2;
                    opt_len -= 4;       /* option header */

-                   ND_PRINT((ndo, " NAK LIST"));
+                   ND_PRINT(" NAK LIST");

                    while (opt_len) {
                        if (opt_len < 4) {
                    while (opt_len) {
                        if (opt_len < 4) {

-                           ND_PRINT((ndo, "[Option length not a multiple of 4]"));
+                           ND_PRINT("[Option length not a multiple of 4]");

                            return;
                        }
                            return;
                        }

-                       ND_TCHECK_4(bp);
-                       ND_PRINT((ndo, " %u", EXTRACT_BE_U_4(bp)));
+                       ND_PRINT(" %u", GET_BE_U_4(bp));

                        bp += 4;
                        opt_len -= 4;
                        opts_len -= 4;
                        bp += 4;
                        opt_len -= 4;
                        opts_len -= 4;


@@ -534,146 +520,146 @@ pgm_print(netdissect_options *ndo,
                case PGM_OPT_JOIN:
 #define PGM_OPT_JOIN_LEN       (2+2+4)
                    if (opt_len != PGM_OPT_JOIN_LEN) {
                case PGM_OPT_JOIN:
 #define PGM_OPT_JOIN_LEN       (2+2+4)
                    if (opt_len != PGM_OPT_JOIN_LEN) {

-                       ND_PRINT((ndo, "[Bad OPT_JOIN option, length %u != %u]",
-                           opt_len, PGM_OPT_JOIN_LEN));
+                       ND_PRINT("[Bad OPT_JOIN option, length %u != %u]",
+                           opt_len, PGM_OPT_JOIN_LEN);

                        return;
                    }
                    bp += 2;
                        return;
                    }
                    bp += 2;

-                   seq = EXTRACT_BE_U_4(bp);
+                   seq = GET_BE_U_4(bp);

                    bp += 4;
                    bp += 4;

-                   ND_PRINT((ndo, " JOIN %u", seq));
+                   ND_PRINT(" JOIN %u", seq);

                    opts_len -= PGM_OPT_JOIN_LEN;
                    break;
 
                case PGM_OPT_NAK_BO_IVL:
 #define PGM_OPT_NAK_BO_IVL_LEN (2+2+4+4)
                    if (opt_len != PGM_OPT_NAK_BO_IVL_LEN) {
                    opts_len -= PGM_OPT_JOIN_LEN;
                    break;
 
                case PGM_OPT_NAK_BO_IVL:
 #define PGM_OPT_NAK_BO_IVL_LEN (2+2+4+4)
                    if (opt_len != PGM_OPT_NAK_BO_IVL_LEN) {

-                       ND_PRINT((ndo, "[Bad OPT_NAK_BO_IVL option, length %u != %u]",
-                           opt_len, PGM_OPT_NAK_BO_IVL_LEN));
+                       ND_PRINT("[Bad OPT_NAK_BO_IVL option, length %u != %u]",
+                           opt_len, PGM_OPT_NAK_BO_IVL_LEN);

                        return;
                    }
                    bp += 2;
                        return;
                    }
                    bp += 2;

-                   offset = EXTRACT_BE_U_4(bp);
+                   offset = GET_BE_U_4(bp);

                    bp += 4;
                    bp += 4;

-                   seq = EXTRACT_BE_U_4(bp);
+                   seq = GET_BE_U_4(bp);

                    bp += 4;
                    bp += 4;

-                   ND_PRINT((ndo, " BACKOFF ivl %u ivlseq %u", offset, seq));
+                   ND_PRINT(" BACKOFF ivl %u ivlseq %u", offset, seq);

                    opts_len -= PGM_OPT_NAK_BO_IVL_LEN;
                    break;
 
                case PGM_OPT_NAK_BO_RNG:
 #define PGM_OPT_NAK_BO_RNG_LEN (2+2+4+4)
                    if (opt_len != PGM_OPT_NAK_BO_RNG_LEN) {
                    opts_len -= PGM_OPT_NAK_BO_IVL_LEN;
                    break;
 
                case PGM_OPT_NAK_BO_RNG:
 #define PGM_OPT_NAK_BO_RNG_LEN (2+2+4+4)
                    if (opt_len != PGM_OPT_NAK_BO_RNG_LEN) {

-                       ND_PRINT((ndo, "[Bad OPT_NAK_BO_RNG option, length %u != %u]",
-                           opt_len, PGM_OPT_NAK_BO_RNG_LEN));
+                       ND_PRINT("[Bad OPT_NAK_BO_RNG option, length %u != %u]",
+                           opt_len, PGM_OPT_NAK_BO_RNG_LEN);

                        return;
                    }
                    bp += 2;
                        return;
                    }
                    bp += 2;

-                   offset = EXTRACT_BE_U_4(bp);
+                   offset = GET_BE_U_4(bp);

                    bp += 4;
                    bp += 4;

-                   seq = EXTRACT_BE_U_4(bp);
+                   seq = GET_BE_U_4(bp);

                    bp += 4;
                    bp += 4;

-                   ND_PRINT((ndo, " BACKOFF max %u min %u", offset, seq));
+                   ND_PRINT(" BACKOFF max %u min %u", offset, seq);

                    opts_len -= PGM_OPT_NAK_BO_RNG_LEN;
                    break;
 
                case PGM_OPT_REDIRECT:
 #define PGM_OPT_REDIRECT_FIXED_LEN     (2+2+2+2)
                    if (opt_len < PGM_OPT_REDIRECT_FIXED_LEN) {
                    opts_len -= PGM_OPT_NAK_BO_RNG_LEN;
                    break;
 
                case PGM_OPT_REDIRECT:
 #define PGM_OPT_REDIRECT_FIXED_LEN     (2+2+2+2)
                    if (opt_len < PGM_OPT_REDIRECT_FIXED_LEN) {

-                       ND_PRINT((ndo, "[Bad OPT_REDIRECT option, length %u < %u]",
-                           opt_len, PGM_OPT_REDIRECT_FIXED_LEN));
+                       ND_PRINT("[Bad OPT_REDIRECT option, length %u < %u]",
+                           opt_len, PGM_OPT_REDIRECT_FIXED_LEN);

                        return;
                    }
                    bp += 2;
                        return;
                    }
                    bp += 2;

-                   nla_afnum = EXTRACT_BE_U_2(bp);
+                   nla_afnum = GET_BE_U_2(bp);

                    bp += 2+2;
                    switch (nla_afnum) {
                    case AFNUM_INET:
                    bp += 2+2;
                    switch (nla_afnum) {
                    case AFNUM_INET:

-                       if (opt_len != PGM_OPT_REDIRECT_FIXED_LEN + sizeof(struct in_addr)) {
-                           ND_PRINT((ndo, "[Bad OPT_REDIRECT option, length %u != %u + address size]",
-                               opt_len, PGM_OPT_REDIRECT_FIXED_LEN));
+                       if (opt_len != PGM_OPT_REDIRECT_FIXED_LEN + sizeof(nd_ipv4)) {
+                           ND_PRINT("[Bad OPT_REDIRECT option, length %u != %u + address size]",
+                               opt_len, PGM_OPT_REDIRECT_FIXED_LEN);

                            return;
                        }
                            return;
                        }

-                       ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+                       ND_TCHECK_LEN(bp, sizeof(nd_ipv4));

                        addrtostr(bp, nla_buf, sizeof(nla_buf));
                        addrtostr(bp, nla_buf, sizeof(nla_buf));

-                       bp += sizeof(struct in_addr);
-                       opts_len -= PGM_OPT_REDIRECT_FIXED_LEN + sizeof(struct in_addr);
+                       bp += sizeof(nd_ipv4);
+                       opts_len -= PGM_OPT_REDIRECT_FIXED_LEN + sizeof(nd_ipv4);

                        break;
                    case AFNUM_INET6:
                        break;
                    case AFNUM_INET6:

-                       if (opt_len != PGM_OPT_REDIRECT_FIXED_LEN + sizeof(struct in6_addr)) {
-                           ND_PRINT((ndo, "[Bad OPT_REDIRECT option, length %u != %u + address size]",
-                               PGM_OPT_REDIRECT_FIXED_LEN, opt_len));
+                       if (opt_len != PGM_OPT_REDIRECT_FIXED_LEN + sizeof(nd_ipv6)) {
+                           ND_PRINT("[Bad OPT_REDIRECT option, length %u != %u + address size]",
+                               opt_len, PGM_OPT_REDIRECT_FIXED_LEN);

                            return;
                        }
                            return;
                        }

-                       ND_TCHECK_LEN(bp, sizeof(struct in6_addr));
+                       ND_TCHECK_LEN(bp, sizeof(nd_ipv6));

                        addrtostr6(bp, nla_buf, sizeof(nla_buf));
                        addrtostr6(bp, nla_buf, sizeof(nla_buf));

-                       bp += sizeof(struct in6_addr);
-                       opts_len -= PGM_OPT_REDIRECT_FIXED_LEN + sizeof(struct in6_addr);
+                       bp += sizeof(nd_ipv6);
+                       opts_len -= PGM_OPT_REDIRECT_FIXED_LEN + sizeof(nd_ipv6);

                        break;
                    default:
                        goto trunc;
                        break;
                    }
 
                        break;
                    default:
                        goto trunc;
                        break;
                    }
 

-                   ND_PRINT((ndo, " REDIRECT %s",  nla_buf));
+                   ND_PRINT(" REDIRECT %s",  nla_buf);

                    break;
 
                case PGM_OPT_PARITY_PRM:
 #define PGM_OPT_PARITY_PRM_LEN (2+2+4)
                    if (opt_len != PGM_OPT_PARITY_PRM_LEN) {
                    break;
 
                case PGM_OPT_PARITY_PRM:
 #define PGM_OPT_PARITY_PRM_LEN (2+2+4)
                    if (opt_len != PGM_OPT_PARITY_PRM_LEN) {

-                       ND_PRINT((ndo, "[Bad OPT_PARITY_PRM option, length %u != %u]",
-                           opt_len, PGM_OPT_PARITY_PRM_LEN));
+                       ND_PRINT("[Bad OPT_PARITY_PRM option, length %u != %u]",
+                           opt_len, PGM_OPT_PARITY_PRM_LEN);

                        return;
                    }
                    bp += 2;
                        return;
                    }
                    bp += 2;

-                   len = EXTRACT_BE_U_4(bp);
+                   len = GET_BE_U_4(bp);

                    bp += 4;
                    bp += 4;

-                   ND_PRINT((ndo, " PARITY MAXTGS %u", len));
+                   ND_PRINT(" PARITY MAXTGS %u", len);

                    opts_len -= PGM_OPT_PARITY_PRM_LEN;
                    break;
 
                case PGM_OPT_PARITY_GRP:
 #define PGM_OPT_PARITY_GRP_LEN (2+2+4)
                    if (opt_len != PGM_OPT_PARITY_GRP_LEN) {
                    opts_len -= PGM_OPT_PARITY_PRM_LEN;
                    break;
 
                case PGM_OPT_PARITY_GRP:
 #define PGM_OPT_PARITY_GRP_LEN (2+2+4)
                    if (opt_len != PGM_OPT_PARITY_GRP_LEN) {

-                       ND_PRINT((ndo, "[Bad OPT_PARITY_GRP option, length %u != %u]",
-                           opt_len, PGM_OPT_PARITY_GRP_LEN));
+                       ND_PRINT("[Bad OPT_PARITY_GRP option, length %u != %u]",
+                           opt_len, PGM_OPT_PARITY_GRP_LEN);

                        return;
                    }
                    bp += 2;
                        return;
                    }
                    bp += 2;

-                   seq = EXTRACT_BE_U_4(bp);
+                   seq = GET_BE_U_4(bp);

                    bp += 4;
                    bp += 4;

-                   ND_PRINT((ndo, " PARITY GROUP %u", seq));
+                   ND_PRINT(" PARITY GROUP %u", seq);

                    opts_len -= PGM_OPT_PARITY_GRP_LEN;
                    break;
 
                case PGM_OPT_CURR_TGSIZE:
 #define PGM_OPT_CURR_TGSIZE_LEN        (2+2+4)
                    if (opt_len != PGM_OPT_CURR_TGSIZE_LEN) {
                    opts_len -= PGM_OPT_PARITY_GRP_LEN;
                    break;
 
                case PGM_OPT_CURR_TGSIZE:
 #define PGM_OPT_CURR_TGSIZE_LEN        (2+2+4)
                    if (opt_len != PGM_OPT_CURR_TGSIZE_LEN) {

-                       ND_PRINT((ndo, "[Bad OPT_CURR_TGSIZE option, length %u != %u]",
-                           opt_len, PGM_OPT_CURR_TGSIZE_LEN));
+                       ND_PRINT("[Bad OPT_CURR_TGSIZE option, length %u != %u]",
+                           opt_len, PGM_OPT_CURR_TGSIZE_LEN);

                        return;
                    }
                    bp += 2;
                        return;
                    }
                    bp += 2;

-                   len = EXTRACT_BE_U_4(bp);
+                   len = GET_BE_U_4(bp);

                    bp += 4;
                    bp += 4;

-                   ND_PRINT((ndo, " PARITY ATGS %u", len));
+                   ND_PRINT(" PARITY ATGS %u", len);

                    opts_len -= PGM_OPT_CURR_TGSIZE_LEN;
                    break;
 
                case PGM_OPT_NBR_UNREACH:
 #define PGM_OPT_NBR_UNREACH_LEN        (2+2)
                    if (opt_len != PGM_OPT_NBR_UNREACH_LEN) {
                    opts_len -= PGM_OPT_CURR_TGSIZE_LEN;
                    break;
 
                case PGM_OPT_NBR_UNREACH:
 #define PGM_OPT_NBR_UNREACH_LEN        (2+2)
                    if (opt_len != PGM_OPT_NBR_UNREACH_LEN) {

-                       ND_PRINT((ndo, "[Bad OPT_NBR_UNREACH option, length %u != %u]",
-                           opt_len, PGM_OPT_NBR_UNREACH_LEN));
+                       ND_PRINT("[Bad OPT_NBR_UNREACH option, length %u != %u]",
+                           opt_len, PGM_OPT_NBR_UNREACH_LEN);

                        return;
                    }
                    bp += 2;
                        return;
                    }
                    bp += 2;

-                   ND_PRINT((ndo, " NBR_UNREACH"));
+                   ND_PRINT(" NBR_UNREACH");

                    opts_len -= PGM_OPT_NBR_UNREACH_LEN;
                    break;
 
                case PGM_OPT_PATH_NLA:
                    opts_len -= PGM_OPT_NBR_UNREACH_LEN;
                    break;
 
                case PGM_OPT_PATH_NLA:

-                   ND_PRINT((ndo, " PATH_NLA [%u]", opt_len));
+                   ND_PRINT(" PATH_NLA [%u]", opt_len);

                    bp += opt_len;
                    opts_len -= opt_len;
                    break;
                    bp += opt_len;
                    opts_len -= opt_len;
                    break;


@@ -681,41 +667,41 @@ pgm_print(netdissect_options *ndo,
                case PGM_OPT_SYN:
 #define PGM_OPT_SYN_LEN        (2+2)
                    if (opt_len != PGM_OPT_SYN_LEN) {
                case PGM_OPT_SYN:
 #define PGM_OPT_SYN_LEN        (2+2)
                    if (opt_len != PGM_OPT_SYN_LEN) {

-                       ND_PRINT((ndo, "[Bad OPT_SYN option, length %u != %u]",
-                           opt_len, PGM_OPT_SYN_LEN));
+                       ND_PRINT("[Bad OPT_SYN option, length %u != %u]",
+                           opt_len, PGM_OPT_SYN_LEN);

                        return;
                    }
                    bp += 2;
                        return;
                    }
                    bp += 2;

-                   ND_PRINT((ndo, " SYN"));
+                   ND_PRINT(" SYN");

                    opts_len -= PGM_OPT_SYN_LEN;
                    break;
 
                case PGM_OPT_FIN:
 #define PGM_OPT_FIN_LEN        (2+2)
                    if (opt_len != PGM_OPT_FIN_LEN) {
                    opts_len -= PGM_OPT_SYN_LEN;
                    break;
 
                case PGM_OPT_FIN:
 #define PGM_OPT_FIN_LEN        (2+2)
                    if (opt_len != PGM_OPT_FIN_LEN) {

-                       ND_PRINT((ndo, "[Bad OPT_FIN option, length %u != %u]",
-                           opt_len, PGM_OPT_FIN_LEN));
+                       ND_PRINT("[Bad OPT_FIN option, length %u != %u]",
+                           opt_len, PGM_OPT_FIN_LEN);

                        return;
                    }
                    bp += 2;
                        return;
                    }
                    bp += 2;

-                   ND_PRINT((ndo, " FIN"));
+                   ND_PRINT(" FIN");

                    opts_len -= PGM_OPT_FIN_LEN;
                    break;
 
                case PGM_OPT_RST:
 #define PGM_OPT_RST_LEN        (2+2)
                    if (opt_len != PGM_OPT_RST_LEN) {
                    opts_len -= PGM_OPT_FIN_LEN;
                    break;
 
                case PGM_OPT_RST:
 #define PGM_OPT_RST_LEN        (2+2)
                    if (opt_len != PGM_OPT_RST_LEN) {

-                       ND_PRINT((ndo, "[Bad OPT_RST option, length %u != %u]",
-                           opt_len, PGM_OPT_RST_LEN));
+                       ND_PRINT("[Bad OPT_RST option, length %u != %u]",
+                           opt_len, PGM_OPT_RST_LEN);

                        return;
                    }
                    bp += 2;
                        return;
                    }
                    bp += 2;

-                   ND_PRINT((ndo, " RST"));
+                   ND_PRINT(" RST");

                    opts_len -= PGM_OPT_RST_LEN;
                    break;
 
                case PGM_OPT_CR:
                    opts_len -= PGM_OPT_RST_LEN;
                    break;
 
                case PGM_OPT_CR:

-                   ND_PRINT((ndo, " CR"));
+                   ND_PRINT(" CR");

                    bp += opt_len;
                    opts_len -= opt_len;
                    break;
                    bp += opt_len;
                    opts_len -= opt_len;
                    break;


@@ -723,103 +709,103 @@ pgm_print(netdissect_options *ndo,
                case PGM_OPT_CRQST:
 #define PGM_OPT_CRQST_LEN      (2+2)
                    if (opt_len != PGM_OPT_CRQST_LEN) {
                case PGM_OPT_CRQST:
 #define PGM_OPT_CRQST_LEN      (2+2)
                    if (opt_len != PGM_OPT_CRQST_LEN) {

-                       ND_PRINT((ndo, "[Bad OPT_CRQST option, length %u != %u]",
-                           opt_len, PGM_OPT_CRQST_LEN));
+                       ND_PRINT("[Bad OPT_CRQST option, length %u != %u]",
+                           opt_len, PGM_OPT_CRQST_LEN);

                        return;
                    }
                    bp += 2;
                        return;
                    }
                    bp += 2;

-                   ND_PRINT((ndo, " CRQST"));
+                   ND_PRINT(" CRQST");

                    opts_len -= PGM_OPT_CRQST_LEN;
                    break;
 
                case PGM_OPT_PGMCC_DATA:
 #define PGM_OPT_PGMCC_DATA_FIXED_LEN   (2+2+4+2+2)
                    if (opt_len < PGM_OPT_PGMCC_DATA_FIXED_LEN) {
                    opts_len -= PGM_OPT_CRQST_LEN;
                    break;
 
                case PGM_OPT_PGMCC_DATA:
 #define PGM_OPT_PGMCC_DATA_FIXED_LEN   (2+2+4+2+2)
                    if (opt_len < PGM_OPT_PGMCC_DATA_FIXED_LEN) {

-                       ND_PRINT((ndo, "[Bad OPT_PGMCC_DATA option, length %u < %u]",
-                           opt_len, PGM_OPT_PGMCC_DATA_FIXED_LEN));
+                       ND_PRINT("[Bad OPT_PGMCC_DATA option, length %u < %u]",
+                           opt_len, PGM_OPT_PGMCC_DATA_FIXED_LEN);

                        return;
                    }
                    bp += 2;
                        return;
                    }
                    bp += 2;

-                   offset = EXTRACT_BE_U_4(bp);
+                   offset = GET_BE_U_4(bp);

                    bp += 4;
                    bp += 4;

-                   nla_afnum = EXTRACT_BE_U_2(bp);
+                   nla_afnum = GET_BE_U_2(bp);

                    bp += 2+2;
                    switch (nla_afnum) {
                    case AFNUM_INET:
                    bp += 2+2;
                    switch (nla_afnum) {
                    case AFNUM_INET:

-                       if (opt_len != PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(struct in_addr)) {
-                           ND_PRINT((ndo, "[Bad OPT_PGMCC_DATA option, length %u != %u + address size]",
-                               opt_len, PGM_OPT_PGMCC_DATA_FIXED_LEN));
+                       if (opt_len != PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(nd_ipv4)) {
+                           ND_PRINT("[Bad OPT_PGMCC_DATA option, length %u != %u + address size]",
+                               opt_len, PGM_OPT_PGMCC_DATA_FIXED_LEN);

                            return;
                        }
                            return;
                        }

-                       ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+                       ND_TCHECK_LEN(bp, sizeof(nd_ipv4));

                        addrtostr(bp, nla_buf, sizeof(nla_buf));
                        addrtostr(bp, nla_buf, sizeof(nla_buf));

-                       bp += sizeof(struct in_addr);
-                       opts_len -= PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(struct in_addr);
+                       bp += sizeof(nd_ipv4);
+                       opts_len -= PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(nd_ipv4);

                        break;
                    case AFNUM_INET6:
                        break;
                    case AFNUM_INET6:

-                       if (opt_len != PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(struct in6_addr)) {
-                           ND_PRINT((ndo, "[Bad OPT_PGMCC_DATA option, length %u != %u + address size]",
-                               opt_len, PGM_OPT_PGMCC_DATA_FIXED_LEN));
+                       if (opt_len != PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(nd_ipv6)) {
+                           ND_PRINT("[Bad OPT_PGMCC_DATA option, length %u != %u + address size]",
+                               opt_len, PGM_OPT_PGMCC_DATA_FIXED_LEN);

                            return;
                        }
                            return;
                        }

-                       ND_TCHECK_LEN(bp, sizeof(struct in6_addr));
+                       ND_TCHECK_LEN(bp, sizeof(nd_ipv6));

                        addrtostr6(bp, nla_buf, sizeof(nla_buf));
                        addrtostr6(bp, nla_buf, sizeof(nla_buf));

-                       bp += sizeof(struct in6_addr);
-                       opts_len -= PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(struct in6_addr);
+                       bp += sizeof(nd_ipv6);
+                       opts_len -= PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(nd_ipv6);

                        break;
                    default:
                        goto trunc;
                        break;
                    }
 
                        break;
                    default:
                        goto trunc;
                        break;
                    }
 

-                   ND_PRINT((ndo, " PGMCC DATA %u %s", offset, nla_buf));
+                   ND_PRINT(" PGMCC DATA %u %s", offset, nla_buf);

                    break;
 
                case PGM_OPT_PGMCC_FEEDBACK:
 #define PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN       (2+2+4+2+2)
                    if (opt_len < PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN) {
                    break;
 
                case PGM_OPT_PGMCC_FEEDBACK:
 #define PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN       (2+2+4+2+2)
                    if (opt_len < PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN) {

-                       ND_PRINT((ndo, "[Bad PGM_OPT_PGMCC_FEEDBACK option, length %u < %u]",
-                           opt_len, PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN));
+                       ND_PRINT("[Bad PGM_OPT_PGMCC_FEEDBACK option, length %u < %u]",
+                           opt_len, PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN);

                        return;
                    }
                    bp += 2;
                        return;
                    }
                    bp += 2;

-                   offset = EXTRACT_BE_U_4(bp);
+                   offset = GET_BE_U_4(bp);

                    bp += 4;
                    bp += 4;

-                   nla_afnum = EXTRACT_BE_U_2(bp);
+                   nla_afnum = GET_BE_U_2(bp);

                    bp += 2+2;
                    switch (nla_afnum) {
                    case AFNUM_INET:
                    bp += 2+2;
                    switch (nla_afnum) {
                    case AFNUM_INET:

-                       if (opt_len != PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(struct in_addr)) {
-                           ND_PRINT((ndo, "[Bad OPT_PGMCC_FEEDBACK option, length %u != %u + address size]",
-                               opt_len, PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN));
+                       if (opt_len != PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(nd_ipv4)) {
+                           ND_PRINT("[Bad OPT_PGMCC_FEEDBACK option, length %u != %u + address size]",
+                               opt_len, PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN);

                            return;
                        }
                            return;
                        }

-                       ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+                       ND_TCHECK_LEN(bp, sizeof(nd_ipv4));

                        addrtostr(bp, nla_buf, sizeof(nla_buf));
                        addrtostr(bp, nla_buf, sizeof(nla_buf));

-                       bp += sizeof(struct in_addr);
-                       opts_len -= PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(struct in_addr);
+                       bp += sizeof(nd_ipv4);
+                       opts_len -= PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(nd_ipv4);

                        break;
                    case AFNUM_INET6:
                        break;
                    case AFNUM_INET6:

-                       if (opt_len != PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(struct in6_addr)) {
-                           ND_PRINT((ndo, "[Bad OPT_PGMCC_FEEDBACK option, length %u != %u + address size]",
-                               opt_len, PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN));
+                       if (opt_len != PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(nd_ipv6)) {
+                           ND_PRINT("[Bad OPT_PGMCC_FEEDBACK option, length %u != %u + address size]",
+                               opt_len, PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN);

                            return;
                        }
                            return;
                        }

-                       ND_TCHECK_LEN(bp, sizeof(struct in6_addr));
+                       ND_TCHECK_LEN(bp, sizeof(nd_ipv6));

                        addrtostr6(bp, nla_buf, sizeof(nla_buf));
                        addrtostr6(bp, nla_buf, sizeof(nla_buf));

-                       bp += sizeof(struct in6_addr);
-                       opts_len -= PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(struct in6_addr);
+                       bp += sizeof(nd_ipv6);
+                       opts_len -= PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(nd_ipv6);

                        break;
                    default:
                        goto trunc;
                        break;
                    }
 
                        break;
                    default:
                        goto trunc;
                        break;
                    }
 

-                   ND_PRINT((ndo, " PGMCC FEEDBACK %u %s", offset, nla_buf));
+                   ND_PRINT(" PGMCC FEEDBACK %u %s", offset, nla_buf);

                    break;
 
                default:
                    break;
 
                default:

-                   ND_PRINT((ndo, " OPT_%02X [%u] ", opt_type, opt_len));
+                   ND_PRINT(" OPT_%02X [%u] ", opt_type, opt_len);

                    bp += opt_len;
                    opts_len -= opt_len;
                    break;
                    bp += opt_len;
                    opts_len -= opt_len;
                    break;


@@ -830,16 +816,14 @@ pgm_print(netdissect_options *ndo,
             }
        }
 
             }
        }
 

-       ND_PRINT((ndo, " [%u]", length));
+       ND_PRINT(" [%u]", length);

        if (ndo->ndo_packettype == PT_PGM_ZMTP1 &&
            (pgm_type_val == PGM_ODATA || pgm_type_val == PGM_RDATA))
                zmtp1_datagram_print(ndo, bp,
        if (ndo->ndo_packettype == PT_PGM_ZMTP1 &&
            (pgm_type_val == PGM_ODATA || pgm_type_val == PGM_RDATA))
                zmtp1_datagram_print(ndo, bp,

-                                    EXTRACT_BE_U_2(pgm->pgm_length));
+                                    GET_BE_U_2(pgm->pgm_length));

 
        return;
 
 trunc:
 
        return;
 
 trunc:

-       ND_PRINT((ndo, "[|pgm]"));
-       if (ch != '\0')
-               ND_PRINT((ndo, ">"));
+       nd_print_trunc(ndo);

 }
 }