Added support to print radius attribute CUI

[tcpdump] / print-bootp.c

diff --git a/print-bootp.c b/print-bootp.c
index 1594a3984d81660fb0922e111e97e8c2c14fa429..4da4f95250b7921868ba26ed69c462b68a8e4f9f 100644 (file)
--- a/print-bootp.c
+++ b/print-bootp.c
@@ -21,25 +21,24 @@
  * Format and print bootp packets.
  */
 
  * Format and print bootp packets.
  */
 

+#define NETDISSECT_REWORKED

 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <tcpdump-stdinc.h>
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <tcpdump-stdinc.h>
 

-#include <stdio.h>

 #include <string.h>
 
 #include "interface.h"
 #include "addrtoname.h"
 #include "extract.h"
 #include <string.h>
 
 #include "interface.h"
 #include "addrtoname.h"
 #include "extract.h"

-#include "ether.h"

 #include "bootp.h"
 
 static const char tstr[] = " [|bootp]";
 
 #include "bootp.h"
 
 static const char tstr[] = " [|bootp]";
 

-static void rfc1048_print(const u_char *);
-static void cmu_print(const u_char *);
+static void rfc1048_print(netdissect_options *, const u_char *);
+static void cmu_print(netdissect_options *, const u_char *);

 static char *client_fqdn_flags(u_int flags);
 
 static const struct tok bootp_flag_values[] = {
 static char *client_fqdn_flags(u_int flags);
 
 static const struct tok bootp_flag_values[] = {


@@ -57,117 +56,118 @@ static const struct tok bootp_op_values[] = {
  * Print bootp requests
  */
 void
  * Print bootp requests
  */
 void

-bootp_print(register const u_char *cp, u_int length)
+bootp_print(netdissect_options *ndo,
+            register const u_char *cp, u_int length)

 {
        register const struct bootp *bp;
        static const u_char vm_cmu[4] = VM_CMU;
        static const u_char vm_rfc1048[4] = VM_RFC1048;
 
        bp = (const struct bootp *)cp;
 {
        register const struct bootp *bp;
        static const u_char vm_cmu[4] = VM_CMU;
        static const u_char vm_rfc1048[4] = VM_RFC1048;
 
        bp = (const struct bootp *)cp;

-       TCHECK(bp->bp_op);
+       ND_TCHECK(bp->bp_op);

 
 

-        printf("BOOTP/DHCP, %s",
-              tok2str(bootp_op_values, "unknown (0x%02x)", bp->bp_op));
+       ND_PRINT((ndo, "BOOTP/DHCP, %s",
+                 tok2str(bootp_op_values, "unknown (0x%02x)", bp->bp_op)));

 
        if (bp->bp_htype == 1 && bp->bp_hlen == 6 && bp->bp_op == BOOTPREQUEST) {
 
        if (bp->bp_htype == 1 && bp->bp_hlen == 6 && bp->bp_op == BOOTPREQUEST) {

-               TCHECK2(bp->bp_chaddr[0], 6);
-               printf(" from %s", etheraddr_string(bp->bp_chaddr));
+               ND_TCHECK2(bp->bp_chaddr[0], 6);
+               ND_PRINT((ndo, " from %s", etheraddr_string(ndo, bp->bp_chaddr)));

        }
 
        }
 

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

 
 

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

 
 

-       TCHECK(bp->bp_secs);
+       ND_TCHECK(bp->bp_secs);

 
        /* The usual hardware address type is 1 (10Mb Ethernet) */
        if (bp->bp_htype != 1)
 
        /* The usual hardware address type is 1 (10Mb Ethernet) */
        if (bp->bp_htype != 1)

-               printf(", htype %d", bp->bp_htype);
+               ND_PRINT((ndo, ", htype %d", bp->bp_htype));

 
        /* The usual length for 10Mb Ethernet address is 6 bytes */
        if (bp->bp_htype != 1 || bp->bp_hlen != 6)
 
        /* The usual length for 10Mb Ethernet address is 6 bytes */
        if (bp->bp_htype != 1 || bp->bp_hlen != 6)

-               printf(", hlen %d", bp->bp_hlen);
+               ND_PRINT((ndo, ", hlen %d", bp->bp_hlen));

 
        /* Only print interesting fields */
        if (bp->bp_hops)
 
        /* Only print interesting fields */
        if (bp->bp_hops)

-               printf(", hops %d", bp->bp_hops);
+               ND_PRINT((ndo, ", hops %d", bp->bp_hops));

        if (EXTRACT_32BITS(&bp->bp_xid))
        if (EXTRACT_32BITS(&bp->bp_xid))

-               printf(", xid 0x%x", EXTRACT_32BITS(&bp->bp_xid));
+               ND_PRINT((ndo, ", xid 0x%x", EXTRACT_32BITS(&bp->bp_xid)));

        if (EXTRACT_16BITS(&bp->bp_secs))
        if (EXTRACT_16BITS(&bp->bp_secs))

-               printf(", secs %d", EXTRACT_16BITS(&bp->bp_secs));
+               ND_PRINT((ndo, ", secs %d", EXTRACT_16BITS(&bp->bp_secs)));

 
 

-       printf(", Flags [%s]",
-               bittok2str(bootp_flag_values, "none", EXTRACT_16BITS(&bp->bp_flags)));
-       if (vflag > 1)
-               printf(" (0x%04x)", EXTRACT_16BITS(&bp->bp_flags));
+       ND_PRINT((ndo, ", Flags [%s]",
+               bittok2str(bootp_flag_values, "none", EXTRACT_16BITS(&bp->bp_flags))));
+       if (ndo->ndo_vflag > 1)
+               ND_PRINT((ndo, " (0x%04x)", EXTRACT_16BITS(&bp->bp_flags)));

 
        /* Client's ip address */
 
        /* Client's ip address */

-       TCHECK(bp->bp_ciaddr);
+       ND_TCHECK(bp->bp_ciaddr);

        if (EXTRACT_32BITS(&bp->bp_ciaddr.s_addr))
        if (EXTRACT_32BITS(&bp->bp_ciaddr.s_addr))

-               printf("\n\t  Client-IP %s", ipaddr_string(&bp->bp_ciaddr));
+               ND_PRINT((ndo, "\n\t  Client-IP %s", ipaddr_string(ndo, &bp->bp_ciaddr)));

 
        /* 'your' ip address (bootp client) */
 
        /* 'your' ip address (bootp client) */

-       TCHECK(bp->bp_yiaddr);
+       ND_TCHECK(bp->bp_yiaddr);

        if (EXTRACT_32BITS(&bp->bp_yiaddr.s_addr))
        if (EXTRACT_32BITS(&bp->bp_yiaddr.s_addr))

-               printf("\n\t  Your-IP %s", ipaddr_string(&bp->bp_yiaddr));
+               ND_PRINT((ndo, "\n\t  Your-IP %s", ipaddr_string(ndo, &bp->bp_yiaddr)));

 
        /* Server's ip address */
 
        /* Server's ip address */

-       TCHECK(bp->bp_siaddr);
+       ND_TCHECK(bp->bp_siaddr);

        if (EXTRACT_32BITS(&bp->bp_siaddr.s_addr))
        if (EXTRACT_32BITS(&bp->bp_siaddr.s_addr))

-               printf("\n\t  Server-IP %s", ipaddr_string(&bp->bp_siaddr));
+               ND_PRINT((ndo, "\n\t  Server-IP %s", ipaddr_string(ndo, &bp->bp_siaddr)));

 
        /* Gateway's ip address */
 
        /* Gateway's ip address */

-       TCHECK(bp->bp_giaddr);
+       ND_TCHECK(bp->bp_giaddr);

        if (EXTRACT_32BITS(&bp->bp_giaddr.s_addr))
        if (EXTRACT_32BITS(&bp->bp_giaddr.s_addr))

-               printf("\n\t  Gateway-IP %s", ipaddr_string(&bp->bp_giaddr));
+               ND_PRINT((ndo, "\n\t  Gateway-IP %s", ipaddr_string(ndo, &bp->bp_giaddr)));

 
        /* Client's Ethernet address */
        if (bp->bp_htype == 1 && bp->bp_hlen == 6) {
 
        /* Client's Ethernet address */
        if (bp->bp_htype == 1 && bp->bp_hlen == 6) {

-               TCHECK2(bp->bp_chaddr[0], 6);
-               printf("\n\t  Client-Ethernet-Address %s", etheraddr_string(bp->bp_chaddr));
+               ND_TCHECK2(bp->bp_chaddr[0], 6);
+               ND_PRINT((ndo, "\n\t  Client-Ethernet-Address %s", etheraddr_string(ndo, bp->bp_chaddr)));

        }
 
        }
 

-       TCHECK2(bp->bp_sname[0], 1);            /* check first char only */
+       ND_TCHECK2(bp->bp_sname[0], 1);         /* check first char only */

        if (*bp->bp_sname) {
        if (*bp->bp_sname) {

-               printf("\n\t  sname \"");
-               if (fn_print(bp->bp_sname, snapend)) {
-                       putchar('"');
-                       fputs(tstr + 1, stdout);
+               ND_PRINT((ndo, "\n\t  sname \""));
+               if (fn_print(ndo, bp->bp_sname, ndo->ndo_snapend)) {
+                       ND_PRINT((ndo, "\""));
+                       ND_PRINT((ndo, "%s", tstr + 1));

                        return;
                }
                        return;
                }

-               putchar('"');
+               ND_PRINT((ndo, "\""));

        }
        }

-       TCHECK2(bp->bp_file[0], 1);             /* check first char only */
+       ND_TCHECK2(bp->bp_file[0], 1);          /* check first char only */

        if (*bp->bp_file) {
        if (*bp->bp_file) {

-               printf("\n\t  file \"");
-               if (fn_print(bp->bp_file, snapend)) {
-                       putchar('"');
-                       fputs(tstr + 1, stdout);
+               ND_PRINT((ndo, "\n\t  file \""));
+               if (fn_print(ndo, bp->bp_file, ndo->ndo_snapend)) {
+                       ND_PRINT((ndo, "\""));
+                       ND_PRINT((ndo, "%s", tstr + 1));

                        return;
                }
                        return;
                }

-               putchar('"');
+               ND_PRINT((ndo, "\""));

        }
 
        /* Decode the vendor buffer */
        }
 
        /* Decode the vendor buffer */

-       TCHECK(bp->bp_vend[0]);
+       ND_TCHECK(bp->bp_vend[0]);

        if (memcmp((const char *)bp->bp_vend, vm_rfc1048,
        if (memcmp((const char *)bp->bp_vend, vm_rfc1048,

-                sizeof(u_int32_t)) == 0)
-               rfc1048_print(bp->bp_vend);
+                sizeof(uint32_t)) == 0)
+               rfc1048_print(ndo, bp->bp_vend);

        else if (memcmp((const char *)bp->bp_vend, vm_cmu,
        else if (memcmp((const char *)bp->bp_vend, vm_cmu,

-                     sizeof(u_int32_t)) == 0)
-               cmu_print(bp->bp_vend);
+                     sizeof(uint32_t)) == 0)
+               cmu_print(ndo, bp->bp_vend);

        else {
        else {

-               u_int32_t ul;
+               uint32_t ul;

 
                ul = EXTRACT_32BITS(&bp->bp_vend);
                if (ul != 0)
 
                ul = EXTRACT_32BITS(&bp->bp_vend);
                if (ul != 0)

-                       printf("\n\t  Vendor-#0x%x", ul);
+                       ND_PRINT((ndo, "\n\t  Vendor-#0x%x", ul));

        }
 
        return;
 trunc:
        }
 
        return;
 trunc:

-       fputs(tstr, stdout);
+       ND_PRINT((ndo, "%s", tstr));

 }
 
 /*
 }
 
 /*


@@ -360,32 +360,33 @@ static const struct tok agent_suboption_values[] = {
 
 
 static void
 
 
 static void

-rfc1048_print(register const u_char *bp)
+rfc1048_print(netdissect_options *ndo,
+              register const u_char *bp)

 {
 {

-       register u_int16_t tag;
+       register uint16_t tag;

        register u_int len;
        register const char *cp;
        register char c;
        int first, idx;
        register u_int len;
        register const char *cp;
        register char c;
        int first, idx;

-       u_int32_t ul;
-       u_int16_t us;
-       u_int8_t uc, subopt, suboptlen;
+       uint32_t ul;
+       uint16_t us;
+       uint8_t uc, subopt, suboptlen;

 
 

-       printf("\n\t  Vendor-rfc1048 Extensions");
+       ND_PRINT((ndo, "\n\t  Vendor-rfc1048 Extensions"));

 
        /* Step over magic cookie */
 
        /* Step over magic cookie */

-        printf("\n\t    Magic Cookie 0x%08x", EXTRACT_32BITS(bp));
+       ND_PRINT((ndo, "\n\t    Magic Cookie 0x%08x", EXTRACT_32BITS(bp)));

        bp += sizeof(int32_t);
 
        /* Loop while we there is a tag left in the buffer */
        bp += sizeof(int32_t);
 
        /* Loop while we there is a tag left in the buffer */

-       while (TTEST2(*bp, 1)) {
+       while (ND_TTEST2(*bp, 1)) {

                tag = *bp++;
                tag = *bp++;

-               if (tag == TAG_PAD && vflag < 3)
+               if (tag == TAG_PAD && ndo->ndo_vflag < 3)

                        continue;
                        continue;

-               if (tag == TAG_END && vflag < 3)
+               if (tag == TAG_END && ndo->ndo_vflag < 3)

                        return;
                if (tag == TAG_EXTENDED_OPTION) {
                        return;
                if (tag == TAG_EXTENDED_OPTION) {

-                       TCHECK2(*(bp + 1), 2);
+                       ND_TCHECK2(*(bp + 1), 2);

                        tag = EXTRACT_16BITS(bp + 1);
                        /* XXX we don't know yet if the IANA will
                         * preclude overlap of 1-byte and 2-byte spaces.
                        tag = EXTRACT_16BITS(bp + 1);
                        /* XXX we don't know yet if the IANA will
                         * preclude overlap of 1-byte and 2-byte spaces.


@@ -400,32 +401,32 @@ rfc1048_print(register const u_char *bp)
                        len = 0;
                else {
                        /* Get the length; check for truncation */
                        len = 0;
                else {
                        /* Get the length; check for truncation */

-                       TCHECK2(*bp, 1);
+                       ND_TCHECK2(*bp, 1);

                        len = *bp++;
                }
 
                        len = *bp++;
                }
 

-               printf("\n\t    %s Option %u, length %u%s", cp, tag, len,
-                   len > 0 ? ": " : "");
+               ND_PRINT((ndo, "\n\t    %s Option %u, length %u%s", cp, tag, len,
+                   len > 0 ? ": " : ""));

 
 

-               if (tag == TAG_PAD && vflag > 2) {
+               if (tag == TAG_PAD && ndo->ndo_vflag > 2) {

                        u_int ntag = 1;
                        u_int ntag = 1;

-                       while (TTEST2(*bp, 1) && *bp == TAG_PAD) {
+                       while (ND_TTEST2(*bp, 1) && *bp == TAG_PAD) {

                                bp++;
                                ntag++;
                        }
                        if (ntag > 1)
                                bp++;
                                ntag++;
                        }
                        if (ntag > 1)

-                               printf(", occurs %u", ntag);
+                               ND_PRINT((ndo, ", occurs %u", ntag));

                }
 
                }
 

-               if (!TTEST2(*bp, len)) {
-                       printf("[|rfc1048 %u]", len);
+               if (!ND_TTEST2(*bp, len)) {
+                       ND_PRINT((ndo, "[|rfc1048 %u]", len));

                        return;
                }
 
                if (tag == TAG_DHCP_MESSAGE && len == 1) {
                        uc = *bp++;
                        return;
                }
 
                if (tag == TAG_DHCP_MESSAGE && len == 1) {
                        uc = *bp++;

-                        printf("%s", tok2str(dhcp_msg_values, "Unknown (%u)", uc));
-                        continue;
+                       ND_PRINT((ndo, "%s", tok2str(dhcp_msg_values, "Unknown (%u)", uc)));
+                       continue;

                }
 
                if (tag == TAG_PARM_REQUEST) {
                }
 
                if (tag == TAG_PARM_REQUEST) {


@@ -434,10 +435,10 @@ rfc1048_print(register const u_char *bp)
                                uc = *bp++;
                                cp = tok2str(tag2str, "?Option %u", uc);
                                if (idx % 4 == 0)
                                uc = *bp++;
                                cp = tok2str(tag2str, "?Option %u", uc);
                                if (idx % 4 == 0)

-                                       printf("\n\t      ");
+                                       ND_PRINT((ndo, "\n\t      "));

                                else
                                else

-                                       printf(", ");
-                               printf("%s", cp + 1);
+                                       ND_PRINT((ndo, ", "));
+                               ND_PRINT((ndo, "%s", cp + 1));

                                idx++;
                        }
                        continue;
                                idx++;
                        }
                        continue;


@@ -451,8 +452,8 @@ rfc1048_print(register const u_char *bp)
                                bp += 2;
                                cp = tok2str(xtag2str, "?xT%u", us);
                                if (!first)
                                bp += 2;
                                cp = tok2str(xtag2str, "?xT%u", us);
                                if (!first)

-                                       putchar('+');
-                               printf("%s", cp + 1);
+                                       ND_PRINT((ndo, "+"));
+                               ND_PRINT((ndo, "%s", cp + 1));

                                first = 0;
                        }
                        continue;
                                first = 0;
                        }
                        continue;


@@ -473,12 +474,12 @@ rfc1048_print(register const u_char *bp)
 
                case 'a':
                        /* ascii strings */
 
                case 'a':
                        /* ascii strings */

-                       putchar('"');
-                       if (fn_printn(bp, len, snapend)) {
-                               putchar('"');
+                       ND_PRINT((ndo, "\""));
+                       if (fn_printn(ndo, bp, len, ndo->ndo_snapend)) {
+                               ND_PRINT((ndo, "\""));

                                goto trunc;
                        }
                                goto trunc;
                        }

-                       putchar('"');
+                       ND_PRINT((ndo, "\""));

                        bp += len;
                        len = 0;
                        break;
                        bp += len;
                        len = 0;
                        break;


@@ -489,15 +490,15 @@ rfc1048_print(register const u_char *bp)
                        /* ip addresses/32-bit words */
                        while (len >= sizeof(ul)) {
                                if (!first)
                        /* ip addresses/32-bit words */
                        while (len >= sizeof(ul)) {
                                if (!first)

-                                       putchar(',');
+                                       ND_PRINT((ndo, ","));

                                ul = EXTRACT_32BITS(bp);
                                if (c == 'i') {
                                        ul = htonl(ul);
                                ul = EXTRACT_32BITS(bp);
                                if (c == 'i') {
                                        ul = htonl(ul);

-                                       printf("%s", ipaddr_string(&ul));
+                                       ND_PRINT((ndo, "%s", ipaddr_string(ndo, &ul)));

                                } else if (c == 'L')
                                } else if (c == 'L')

-                                       printf("%d", ul);
+                                       ND_PRINT((ndo, "%d", ul));

                                else
                                else

-                                       printf("%u", ul);
+                                       ND_PRINT((ndo, "%u", ul));

                                bp += sizeof(ul);
                                len -= sizeof(ul);
                                first = 0;
                                bp += sizeof(ul);
                                len -= sizeof(ul);
                                first = 0;


@@ -508,12 +509,12 @@ rfc1048_print(register const u_char *bp)
                        /* IP address pairs */
                        while (len >= 2*sizeof(ul)) {
                                if (!first)
                        /* IP address pairs */
                        while (len >= 2*sizeof(ul)) {
                                if (!first)

-                                       putchar(',');
+                                       ND_PRINT((ndo, ","));

                                memcpy((char *)&ul, (const char *)bp, sizeof(ul));
                                memcpy((char *)&ul, (const char *)bp, sizeof(ul));

-                               printf("(%s:", ipaddr_string(&ul));
+                               ND_PRINT((ndo, "(%s:", ipaddr_string(ndo, &ul)));

                                bp += sizeof(ul);
                                memcpy((char *)&ul, (const char *)bp, sizeof(ul));
                                bp += sizeof(ul);
                                memcpy((char *)&ul, (const char *)bp, sizeof(ul));

-                               printf("%s)", ipaddr_string(&ul));
+                               ND_PRINT((ndo, "%s)", ipaddr_string(ndo, &ul)));

                                bp += sizeof(ul);
                                len -= 2*sizeof(ul);
                                first = 0;
                                bp += sizeof(ul);
                                len -= 2*sizeof(ul);
                                first = 0;


@@ -524,9 +525,9 @@ rfc1048_print(register const u_char *bp)
                        /* shorts */
                        while (len >= sizeof(us)) {
                                if (!first)
                        /* shorts */
                        while (len >= sizeof(us)) {
                                if (!first)

-                                       putchar(',');
+                                       ND_PRINT((ndo, ","));

                                us = EXTRACT_16BITS(bp);
                                us = EXTRACT_16BITS(bp);

-                               printf("%u", us);
+                               ND_PRINT((ndo, "%u", us));

                                bp += sizeof(us);
                                len -= sizeof(us);
                                first = 0;
                                bp += sizeof(us);
                                len -= sizeof(us);
                                first = 0;


@@ -537,16 +538,16 @@ rfc1048_print(register const u_char *bp)
                        /* boolean */
                        while (len > 0) {
                                if (!first)
                        /* boolean */
                        while (len > 0) {
                                if (!first)

-                                       putchar(',');
+                                       ND_PRINT((ndo, ","));

                                switch (*bp) {
                                case 0:
                                switch (*bp) {
                                case 0:

-                                       putchar('N');
+                                       ND_PRINT((ndo, "N"));

                                        break;
                                case 1:
                                        break;
                                case 1:

-                                       putchar('Y');
+                                       ND_PRINT((ndo, "Y"));

                                        break;
                                default:
                                        break;
                                default:

-                                       printf("%u?", *bp);
+                                       ND_PRINT((ndo, "%u?", *bp));

                                        break;
                                }
                                ++bp;
                                        break;
                                }
                                ++bp;


@@ -561,11 +562,11 @@ rfc1048_print(register const u_char *bp)
                        /* Bytes */
                        while (len > 0) {
                                if (!first)
                        /* Bytes */
                        while (len > 0) {
                                if (!first)

-                                       putchar(c == 'x' ? ':' : '.');
+                                       ND_PRINT((ndo, c == 'x' ? ":" : "."));

                                if (c == 'x')
                                if (c == 'x')

-                                       printf("%02x", *bp);
+                                       ND_PRINT((ndo, "%02x", *bp));

                                else
                                else

-                                       printf("%u", *bp);
+                                       ND_PRINT((ndo, "%u", *bp));

                                ++bp;
                                --len;
                                first = 0;
                                ++bp;
                                --len;
                                first = 0;


@@ -579,48 +580,48 @@ rfc1048_print(register const u_char *bp)
                        case TAG_NETBIOS_NODE:
                                /* this option should be at least 1 byte long */
                                if (len < 1)  {
                        case TAG_NETBIOS_NODE:
                                /* this option should be at least 1 byte long */
                                if (len < 1)  {

-                                       printf("ERROR: option %u len %u < 1 bytes",
-                                           TAG_NETBIOS_NODE, len);
+                                       ND_PRINT((ndo, "ERROR: option %u len %u < 1 bytes",
+                                           TAG_NETBIOS_NODE, len));

                                        break;
                                }
                                tag = *bp++;
                                --len;
                                        break;
                                }
                                tag = *bp++;
                                --len;

-                               fputs(tok2str(nbo2str, NULL, tag), stdout);
+                               ND_PRINT((ndo, "%s", tok2str(nbo2str, NULL, tag)));

                                break;
 
                        case TAG_OPT_OVERLOAD:
                                /* this option should be at least 1 byte long */
                                if (len < 1)  {
                                break;
 
                        case TAG_OPT_OVERLOAD:
                                /* this option should be at least 1 byte long */
                                if (len < 1)  {

-                                       printf("ERROR: option %u len %u < 1 bytes",
-                                           TAG_OPT_OVERLOAD, len);
+                                       ND_PRINT((ndo, "ERROR: option %u len %u < 1 bytes",
+                                           TAG_OPT_OVERLOAD, len));

                                        break;
                                }
                                tag = *bp++;
                                --len;
                                        break;
                                }
                                tag = *bp++;
                                --len;

-                               fputs(tok2str(oo2str, NULL, tag), stdout);
+                               ND_PRINT((ndo, "%s", tok2str(oo2str, NULL, tag)));

                                break;
 
                        case TAG_CLIENT_FQDN:
                                /* this option should be at least 3 bytes long */
                                if (len < 3)  {
                                break;
 
                        case TAG_CLIENT_FQDN:
                                /* this option should be at least 3 bytes long */
                                if (len < 3)  {

-                                       printf("ERROR: option %u len %u < 3 bytes",
-                                           TAG_CLIENT_FQDN, len);
+                                       ND_PRINT((ndo, "ERROR: option %u len %u < 3 bytes",
+                                           TAG_CLIENT_FQDN, len));

                                        bp += len;
                                        len = 0;
                                        break;
                                }
                                if (*bp)
                                        bp += len;
                                        len = 0;
                                        break;
                                }
                                if (*bp)

-                                       printf("[%s] ", client_fqdn_flags(*bp));
+                                       ND_PRINT((ndo, "[%s] ", client_fqdn_flags(*bp)));

                                bp++;
                                if (*bp || *(bp+1))
                                bp++;
                                if (*bp || *(bp+1))

-                                       printf("%u/%u ", *bp, *(bp+1));
+                                       ND_PRINT((ndo, "%u/%u ", *bp, *(bp+1)));

                                bp += 2;
                                bp += 2;

-                               putchar('"');
-                               if (fn_printn(bp, len - 3, snapend)) {
-                                       putchar('"');
+                               ND_PRINT((ndo, "\""));
+                               if (fn_printn(ndo, bp, len - 3, ndo->ndo_snapend)) {
+                                       ND_PRINT((ndo, "\""));

                                        goto trunc;
                                }
                                        goto trunc;
                                }

-                               putchar('"');
+                               ND_PRINT((ndo, "\""));

                                bp += len - 3;
                                len = 0;
                                break;
                                bp += len - 3;
                                len = 0;
                                break;


@@ -630,28 +631,28 @@ rfc1048_print(register const u_char *bp)
 
                                /* this option should be at least 1 byte long */
                                if (len < 1)  {
 
                                /* this option should be at least 1 byte long */
                                if (len < 1)  {

-                                       printf("ERROR: option %u len %u < 1 bytes",
-                                           TAG_CLIENT_ID, len);
+                                       ND_PRINT((ndo, "ERROR: option %u len %u < 1 bytes",
+                                           TAG_CLIENT_ID, len));

                                        break;
                                }
                                type = *bp++;
                                len--;
                                if (type == 0) {
                                        break;
                                }
                                type = *bp++;
                                len--;
                                if (type == 0) {

-                                       putchar('"');
-                                       if (fn_printn(bp, len, snapend)) {
-                                               putchar('"');
+                                       ND_PRINT((ndo, "\""));
+                                       if (fn_printn(ndo, bp, len, ndo->ndo_snapend)) {
+                                               ND_PRINT((ndo, "\""));

                                                goto trunc;
                                        }
                                                goto trunc;
                                        }

-                                       putchar('"');
+                                       ND_PRINT((ndo, "\""));

                                        bp += len;
                                        len = 0;
                                        break;
                                } else {
                                        bp += len;
                                        len = 0;
                                        break;
                                } else {

-                                       printf("%s ", tok2str(arp2str, "hardware-type %u,", type));
+                                       ND_PRINT((ndo, "%s ", tok2str(arp2str, "hardware-type %u,", type)));

                                        while (len > 0) {
                                                if (!first)
                                        while (len > 0) {
                                                if (!first)

-                                                       putchar(':');
-                                               printf("%02x", *bp);
+                                                       ND_PRINT((ndo, ":"));
+                                               ND_PRINT((ndo, "%02x", *bp));

                                                ++bp;
                                                --len;
                                                first = 0;
                                                ++bp;
                                                --len;
                                                first = 0;


@@ -666,28 +667,28 @@ rfc1048_print(register const u_char *bp)
                                        suboptlen = *bp++;
                                        len -= 2;
                                        if (suboptlen > len) {
                                        suboptlen = *bp++;
                                        len -= 2;
                                        if (suboptlen > len) {

-                                               printf("\n\t      %s SubOption %u, length %u: length goes past end of option",
+                                               ND_PRINT((ndo, "\n\t      %s SubOption %u, length %u: length goes past end of option",

                                                   tok2str(agent_suboption_values, "Unknown", subopt),
                                                   subopt,
                                                   tok2str(agent_suboption_values, "Unknown", subopt),
                                                   subopt,

-                                                  suboptlen);
+                                                  suboptlen));

                                                bp += len;
                                                len = 0;
                                                break;
                                        }
                                                bp += len;
                                                len = 0;
                                                break;
                                        }

-                                       printf("\n\t      %s SubOption %u, length %u: ",
+                                       ND_PRINT((ndo, "\n\t      %s SubOption %u, length %u: ",

                                           tok2str(agent_suboption_values, "Unknown", subopt),
                                           subopt,
                                           tok2str(agent_suboption_values, "Unknown", subopt),
                                           subopt,

-                                          suboptlen);
+                                          suboptlen));

                                        switch (subopt) {
 
                                        switch (subopt) {
 

-                                        case AGENT_SUBOPTION_CIRCUIT_ID: /* fall through */
-                                        case AGENT_SUBOPTION_REMOTE_ID:
-                                        case AGENT_SUBOPTION_SUBSCRIBER_ID:
-                                                fn_printn(bp, suboptlen, NULL);
-                                                break;
+                                       case AGENT_SUBOPTION_CIRCUIT_ID: /* fall through */
+                                       case AGENT_SUBOPTION_REMOTE_ID:
+                                       case AGENT_SUBOPTION_SUBSCRIBER_ID:
+                                               fn_printn(ndo, bp, suboptlen, NULL);
+                                               break;

 
                                        default:
 
                                        default:

-                                               print_unknown_data(gndo,bp, "\n\t\t", suboptlen);
+                                               print_unknown_data(ndo, bp, "\n\t\t", suboptlen);

                                        }
 
                                        len -= suboptlen;
                                        }
 
                                        len -= suboptlen;


@@ -702,20 +703,20 @@ rfc1048_print(register const u_char *bp)
 
                                /* this option should be at least 5 bytes long */
                                if (len < 5)  {
 
                                /* this option should be at least 5 bytes long */
                                if (len < 5)  {

-                                       printf("ERROR: option %u len %u < 5 bytes",
-                                           TAG_CLASSLESS_STATIC_RT, len);
+                                       ND_PRINT((ndo, "ERROR: option %u len %u < 5 bytes",
+                                           TAG_CLASSLESS_STATIC_RT, len));

                                        bp += len;
                                        len = 0;
                                        break;
                                }
                                while (len > 0) {
                                        if (!first)
                                        bp += len;
                                        len = 0;
                                        break;
                                }
                                while (len > 0) {
                                        if (!first)

-                                               putchar(',');
+                                               ND_PRINT((ndo, ","));

                                        mask_width = *bp++;
                                        len--;
                                        /* mask_width <= 32 */
                                        if (mask_width > 32) {
                                        mask_width = *bp++;
                                        len--;
                                        /* mask_width <= 32 */
                                        if (mask_width > 32) {

-                                               printf("[ERROR: Mask width (%d) > 32]",  mask_width);
+                                               ND_PRINT((ndo, "[ERROR: Mask width (%d) > 32]",  mask_width));

                                                bp += len;
                                                len = 0;
                                                break;
                                                bp += len;
                                                len = 0;
                                                break;


@@ -723,26 +724,26 @@ rfc1048_print(register const u_char *bp)
                                        significant_octets = (mask_width + 7) / 8;
                                        /* significant octets + router(4) */
                                        if (len < significant_octets + 4) {
                                        significant_octets = (mask_width + 7) / 8;
                                        /* significant octets + router(4) */
                                        if (len < significant_octets + 4) {

-                                               printf("[ERROR: Remaining length (%u) < %u bytes]",  len, significant_octets + 4);
+                                               ND_PRINT((ndo, "[ERROR: Remaining length (%u) < %u bytes]",  len, significant_octets + 4));

                                                bp += len;
                                                len = 0;
                                                break;
                                        }
                                                bp += len;
                                                len = 0;
                                                break;
                                        }

-                                       putchar('(');
+                                       ND_PRINT((ndo, "("));

                                        if (mask_width == 0)
                                        if (mask_width == 0)

-                                               printf("default");
+                                               ND_PRINT((ndo, "default"));

                                        else {
                                                for (i = 0; i < significant_octets ; i++) {
                                                        if (i > 0)
                                        else {
                                                for (i = 0; i < significant_octets ; i++) {
                                                        if (i > 0)

-                                                               putchar('.');
-                                                       printf("%d", *bp++);
+                                                               ND_PRINT((ndo, "."));
+                                                       ND_PRINT((ndo, "%d", *bp++));

                                                }
                                                for (i = significant_octets ; i < 4 ; i++)
                                                }
                                                for (i = significant_octets ; i < 4 ; i++)

-                                                       printf(".0");
-                                               printf("/%d", mask_width);
+                                                       ND_PRINT((ndo, ".0"));
+                                               ND_PRINT((ndo, "/%d", mask_width));

                                        }
                                        memcpy((char *)&ul, (const char *)bp, sizeof(ul));
                                        }
                                        memcpy((char *)&ul, (const char *)bp, sizeof(ul));

-                                       printf(":%s)", ipaddr_string(&ul));
+                                       ND_PRINT((ndo, ":%s)", ipaddr_string(ndo, &ul)));

                                        bp += sizeof(ul);
                                        len -= (significant_octets + 4);
                                        first = 0;
                                        bp += sizeof(ul);
                                        len -= (significant_octets + 4);
                                        first = 0;


@@ -751,8 +752,8 @@ rfc1048_print(register const u_char *bp)
                        break;
 
                        default:
                        break;
 
                        default:

-                               printf("[unknown special tag %u, size %u]",
-                                   tag, len);
+                               ND_PRINT((ndo, "[unknown special tag %u, size %u]",
+                                   tag, len));

                                bp += len;
                                len = 0;
                                break;
                                bp += len;
                                len = 0;
                                break;


@@ -761,31 +762,32 @@ rfc1048_print(register const u_char *bp)
                }
                /* Data left over? */
                if (len) {
                }
                /* Data left over? */
                if (len) {

-                       printf("\n\t  trailing data length %u", len);
+                       ND_PRINT((ndo, "\n\t  trailing data length %u", len));

                        bp += len;
                }
        }
        return;
 trunc:
                        bp += len;
                }
        }
        return;
 trunc:

-       printf("|[rfc1048]");
+       ND_PRINT((ndo, "|[rfc1048]"));

 }
 
 static void
 }
 
 static void

-cmu_print(register const u_char *bp)
+cmu_print(netdissect_options *ndo,
+          register const u_char *bp)

 {
        register const struct cmu_vend *cmu;
 
 {
        register const struct cmu_vend *cmu;
 

-#define PRINTCMUADDR(m, s) { TCHECK(cmu->m); \
+#define PRINTCMUADDR(m, s) { ND_TCHECK(cmu->m); \

     if (cmu->m.s_addr != 0) \
     if (cmu->m.s_addr != 0) \

-       printf(" %s:%s", s, ipaddr_string(&cmu->m.s_addr)); }
+       ND_PRINT((ndo, " %s:%s", s, ipaddr_string(ndo, &cmu->m.s_addr))); }

 
 

-       printf(" vend-cmu");
+       ND_PRINT((ndo, " vend-cmu"));

        cmu = (const struct cmu_vend *)bp;
 
        /* Only print if there are unknown bits */
        cmu = (const struct cmu_vend *)bp;
 
        /* Only print if there are unknown bits */

-       TCHECK(cmu->v_flags);
+       ND_TCHECK(cmu->v_flags);

        if ((cmu->v_flags & ~(VF_SMASK)) != 0)
        if ((cmu->v_flags & ~(VF_SMASK)) != 0)

-               printf(" F:0x%x", cmu->v_flags);
+               ND_PRINT((ndo, " F:0x%x", cmu->v_flags));

        PRINTCMUADDR(v_dgate, "DG");
        PRINTCMUADDR(v_smask, cmu->v_flags & VF_SMASK ? "SM" : "SM*");
        PRINTCMUADDR(v_dns1, "NS1");
        PRINTCMUADDR(v_dgate, "DG");
        PRINTCMUADDR(v_smask, cmu->v_flags & VF_SMASK ? "SM" : "SM*");
        PRINTCMUADDR(v_dns1, "NS1");


@@ -797,7 +799,7 @@ cmu_print(register const u_char *bp)
        return;
 
 trunc:
        return;
 
 trunc:

-       fputs(tstr, stdout);
+       ND_PRINT((ndo, "%s", tstr));

 #undef PRINTCMUADDR
 }
 
 #undef PRINTCMUADDR
 }