NDOize LLDP, PPP and RSVP decoders

diff --git a/interface.h b/interface.h
index c4c9c9e5febd73ebbe3e492234922ca5d0468aa9..6f5e10638ba4320885311e7aabaf08dd7dff7749 100644 (file)
--- a/interface.h
+++ b/interface.h
@@ -162,12 +162,6 @@ extern u_int16_t create_osi_cksum(const u_int8_t *, int, int);
 extern void ascii_print(const u_char *, u_int);
 extern void default_print(const u_char *, u_int);
 extern char *q922_string(const u_char *);
 extern void ascii_print(const u_char *, u_int);
 extern void default_print(const u_char *, u_int);
 extern char *q922_string(const u_char *);

-extern void rsvp_print(const u_char *, u_int);
-extern void lldp_print(const u_char *, u_int);
-extern u_int ppp_print(register const u_char *, u_int);
-extern u_int ppp_if_print(const struct pcap_pkthdr *, const u_char *);
-extern u_int ppp_hdlc_if_print(const struct pcap_pkthdr *, const u_char *);
-extern u_int ppp_bsdos_if_print(const struct pcap_pkthdr *, const u_char *);

 extern void timed_print(const u_char *);
 extern char *smb_errstr(int, int);
 extern const char *nt_errstr(u_int32_t);
 extern void timed_print(const u_char *);
 extern char *smb_errstr(int, int);
 extern const char *nt_errstr(u_int32_t);

diff --git a/netdissect.h b/netdissect.h
index 115d1c4ad408c8188c4745a0447ca05eeea602d6..947f296dabb8ce78b279a0fc0f7b8ebda4b3cf59 100644 (file)
--- a/netdissect.h
+++ b/netdissect.h
@@ -518,6 +518,12 @@ extern void tcp_print(netdissect_options *, const u_char *, u_int, const u_char
 extern void ospf_print(netdissect_options *, const u_char *, u_int, const u_char *);
 extern int ospf_print_te_lsa(netdissect_options *, const u_int8_t *, u_int);
 extern int ospf_print_grace_lsa(netdissect_options *, const u_int8_t *, u_int);
 extern void ospf_print(netdissect_options *, const u_char *, u_int, const u_char *);
 extern int ospf_print_te_lsa(netdissect_options *, const u_int8_t *, u_int);
 extern int ospf_print_grace_lsa(netdissect_options *, const u_int8_t *, u_int);

+extern u_int ppp_print(netdissect_options *, register const u_char *, u_int);
+extern u_int ppp_if_print(netdissect_options *, const struct pcap_pkthdr *, const u_char *);
+extern u_int ppp_hdlc_if_print(netdissect_options *, const struct pcap_pkthdr *, const u_char *);
+extern u_int ppp_bsdos_if_print(netdissect_options *, const struct pcap_pkthdr *, const u_char *);
+extern void lldp_print(netdissect_options *, const u_char *, u_int);
+extern void rsvp_print(netdissect_options *, const u_char *, u_int);

 
 /* stuff that has not yet been rototiled */
 
 
 /* stuff that has not yet been rototiled */
 


@@ -531,14 +537,6 @@ extern void nfsreply_print(netdissect_options *,const u_char *,
                           u_int, const u_char *);
 extern void nfsreq_print(netdissect_options *,const u_char *,
                         u_int, const u_char *);
                           u_int, const u_char *);
 extern void nfsreq_print(netdissect_options *,const u_char *,
                         u_int, const u_char *);

-extern void ppp_print(netdissect_options *,
-                     register const u_char *, u_int);
-
-extern void ppp_if_print(u_char *,const struct pcap_pkthdr *, const u_char *);
-extern void ppp_hdlc_if_print(u_char *,
-                             const struct pcap_pkthdr *, const u_char *);
-extern void ppp_bsdos_if_print(u_char *,
-                              const struct pcap_pkthdr *, const u_char *);

 
 extern void timed_print(netdissect_options *,const u_char *, u_int);
 extern char *smb_errstr(netdissect_options *,int, int);
 
 extern void timed_print(netdissect_options *,const u_char *, u_int);
 extern char *smb_errstr(netdissect_options *,int, int);

diff --git a/print-ether.c b/print-ether.c
index 057825dc7e5f6c3d6eb6e8bd2ef7a8f0be4de2da..64b7f338ca4d949aa8f61f84b5ecf7b0185b0426 100644 (file)
--- a/print-ether.c
+++ b/print-ether.c
@@ -376,7 +376,7 @@ ethertype_print(netdissect_options *ndo,
        case ETHERTYPE_PPP:
                if (length) {
                        ND_PRINT((ndo, ": "));
        case ETHERTYPE_PPP:
                if (length) {
                        ND_PRINT((ndo, ": "));

-                       ppp_print(/*ndo,*/p, length);
+                       ppp_print(ndo, p, length);

                }
                return (1);
 
                }
                return (1);
 


@@ -394,7 +394,7 @@ ethertype_print(netdissect_options *ndo,
                return (1);
 
        case ETHERTYPE_LLDP:
                return (1);
 
        case ETHERTYPE_LLDP:

-               lldp_print(/*ndo,*/p, length);
+               lldp_print(ndo, p, length);

                return (1);
 
         case ETHERTYPE_LOOPBACK:
                return (1);
 
         case ETHERTYPE_LOOPBACK:

diff --git a/print-fr.c b/print-fr.c
index 093d526efb8cd600874577c1e4a36daae7e208b7..41ef2e2e7086daa883ad299c1d60039f741e7234 100644 (file)
--- a/print-fr.c
+++ b/print-fr.c
@@ -313,7 +313,7 @@ fr_print(netdissect_options *ndo,
                 break;
 
         case NLPID_PPP:
                 break;
 
         case NLPID_PPP:

-                ppp_print(p, length);
+                ppp_print(ndo, p, length);

                 break;
 
        default:
                 break;
 
        default:

diff --git a/print-gre.c b/print-gre.c
index a8584f485c523a843f60d1b1b201b86ad338b97f..9c22120ba64927c0d2dee0c46757249a0d34fff1 100644 (file)
--- a/print-gre.c
+++ b/print-gre.c
@@ -297,7 +297,7 @@ gre_print_1(netdissect_options *ndo, const u_char *bp, u_int length)
 
        switch (prot) {
        case ETHERTYPE_PPP:
 
        switch (prot) {
        case ETHERTYPE_PPP:

-                ppp_print(bp, len);
+               ppp_print(ndo, bp, len);

                break;
        default:
                ND_PRINT((ndo, "gre-proto-0x%x", prot));
                break;
        default:
                ND_PRINT((ndo, "gre-proto-0x%x", prot));

diff --git a/print-ip.c b/print-ip.c
index 597f08b8ca26c4ff7b22e6b9b0811608d1b47a1b..03b0a87d19780c11a830f31c5f2fca8975a7cc7e 100644 (file)
--- a/print-ip.c
+++ b/print-ip.c
@@ -444,7 +444,7 @@ again:
 #endif /*INET6*/
 
        case IPPROTO_RSVP:
 #endif /*INET6*/
 
        case IPPROTO_RSVP:

-               rsvp_print(ipds->cp, ipds->len);
+               rsvp_print(ndo, ipds->cp, ipds->len);

                break;
 
        case IPPROTO_GRE:
                break;
 
        case IPPROTO_GRE:

diff --git a/print-ip6.c b/print-ip6.c
index 5ca63c008b5e1d48d5126ad7d89b94bef598d516..7fc93d933573a78d407f8de451fe506db9774c9b 100644 (file)
--- a/print-ip6.c
+++ b/print-ip6.c
@@ -248,7 +248,7 @@ ip6_print(netdissect_options *ndo, const u_char *bp, u_int length)
                        return;
 
                case IPPROTO_RSVP:
                        return;
 
                case IPPROTO_RSVP:

-                       rsvp_print(cp, len);
+                       rsvp_print(ndo, cp, len);

                        return;
 
                case IPPROTO_NONE:
                        return;
 
                case IPPROTO_NONE:

diff --git a/print-isoclns.c b/print-isoclns.c
index 1b44ffc71ff7b12d98ad94fee9a39071cb33ddc7..50e268c8439b0f905434ed31db37430c2e2a1dc0 100644 (file)
--- a/print-isoclns.c
+++ b/print-isoclns.c
@@ -709,9 +709,9 @@ void isoclns_print(netdissect_options *ndo,
                break;
 #endif
 
                break;
 #endif
 

-        case NLPID_PPP:
-                ppp_print(p+1, length-1);
-                break;
+       case NLPID_PPP:
+               ppp_print(ndo, p + 1, length - 1);
+               break;

 
        default:
                if (!ndo->ndo_eflag)
 
        default:
                if (!ndo->ndo_eflag)

diff --git a/print-juniper.c b/print-juniper.c
index 2036d0cf348b1448ec341c7dae77bcc7014f1d50..1bdca812b19f4e988af7c74b0cda3ad2d1bb7162 100644 (file)
--- a/print-juniper.c
+++ b/print-juniper.c
@@ -443,7 +443,7 @@ static const struct tok juniper_protocol_values[] = {
 };
 
 static int ip_heuristic_guess(netdissect_options *, register const u_char *, u_int);
 };
 
 static int ip_heuristic_guess(netdissect_options *, register const u_char *, u_int);

-static int juniper_ppp_heuristic_guess(register const u_char *, u_int);
+static int juniper_ppp_heuristic_guess(netdissect_options *, register const u_char *, u_int);

 static int juniper_parse_header(netdissect_options *, const u_char *, const struct pcap_pkthdr *, struct juniper_l2info_t *);
 
 #ifdef DLT_JUNIPER_GGSN
 static int juniper_parse_header(netdissect_options *, const u_char *, const struct pcap_pkthdr *, struct juniper_l2info_t *);
 
 #ifdef DLT_JUNIPER_GGSN


@@ -684,7 +684,7 @@ juniper_ppp_print(netdissect_options *ndo,
 
         p+=l2info.header_len;
         /* this DLT contains nothing but raw ppp frames */
 
         p+=l2info.header_len;
         /* this DLT contains nothing but raw ppp frames */

-        ppp_print(p, l2info.length);
+        ppp_print(ndo, p, l2info.length);

         return l2info.header_len;
 }
 #endif
         return l2info.header_len;
 }
 #endif


@@ -780,7 +780,7 @@ juniper_mlppp_print(netdissect_options *ndo,
              * -> this must be incoming IS-IS over PPP
              */
             if (l2info.cookie[4] == (JUNIPER_LSQ_COOKIE_RE|JUNIPER_LSQ_COOKIE_DIR))
              * -> this must be incoming IS-IS over PPP
              */
             if (l2info.cookie[4] == (JUNIPER_LSQ_COOKIE_RE|JUNIPER_LSQ_COOKIE_DIR))

-                ppp_print(p, l2info.length);
+                ppp_print(ndo, p, l2info.length);

             else
                 ip_print(ndo, p, l2info.length);
             return l2info.header_len;
             else
                 ip_print(ndo, p, l2info.length);
             return l2info.header_len;


@@ -802,11 +802,11 @@ juniper_mlppp_print(netdissect_options *ndo,
         /* zero length cookie ? */
         switch (EXTRACT_16BITS(&l2info.cookie)) {
         case PPP_OSI:
         /* zero length cookie ? */
         switch (EXTRACT_16BITS(&l2info.cookie)) {
         case PPP_OSI:

-            ppp_print(p-2,l2info.length+2);
+            ppp_print(ndo, p - 2, l2info.length + 2);

             break;
         case (PPP_ADDRESS << 8 | PPP_CONTROL): /* fall through */
         default:
             break;
         case (PPP_ADDRESS << 8 | PPP_CONTROL): /* fall through */
         default:

-            ppp_print(p,l2info.length);
+            ppp_print(ndo, p, l2info.length);

             break;
         }
 
             break;
         }
 


@@ -1010,7 +1010,7 @@ juniper_atm2_print(netdissect_options *ndo,
             return l2info.header_len;
         }
 
             return l2info.header_len;
         }
 

-        if(juniper_ppp_heuristic_guess(p, l2info.length) != 0) /* PPPoA vcmux encaps ? */
+        if(juniper_ppp_heuristic_guess(ndo, p, l2info.length) != 0) /* PPPoA vcmux encaps ? */

             return l2info.header_len;
 
         if (ip_heuristic_guess(ndo, p, l2info.length) != 0) /* last try - vcmux encaps ? */
             return l2info.header_len;
 
         if (ip_heuristic_guess(ndo, p, l2info.length) != 0) /* last try - vcmux encaps ? */


@@ -1024,7 +1024,8 @@ juniper_atm2_print(netdissect_options *ndo,
 /* try to guess, based on all PPP protos that are supported in
  * a juniper router if the payload data is encapsulated using PPP */
 static int
 /* try to guess, based on all PPP protos that are supported in
  * a juniper router if the payload data is encapsulated using PPP */
 static int

-juniper_ppp_heuristic_guess(register const u_char *p, u_int length) {
+juniper_ppp_heuristic_guess(netdissect_options *ndo,
+                            register const u_char *p, u_int length) {

 
     switch(EXTRACT_16BITS(p)) {
     case PPP_IP :
 
     switch(EXTRACT_16BITS(p)) {
     case PPP_IP :


@@ -1042,7 +1043,7 @@ juniper_ppp_heuristic_guess(register const u_char *p, u_int length) {
     case PPP_IPV6 :
     case PPP_IPV6CP :
 #endif
     case PPP_IPV6 :
     case PPP_IPV6CP :
 #endif

-        ppp_print(p, length);
+        ppp_print(ndo, p, length);

         break;
 
     default:
         break;
 
     default:

diff --git a/print-l2tp.c b/print-l2tp.c
index 8dde75d1e7e7f5338fac0ff4cfde5ffc06354f20..4423ce3d6cbaf95c36b93f220c54f0cd13dd3551 100644 (file)
--- a/print-l2tp.c
+++ b/print-l2tp.c
@@ -737,7 +737,7 @@ l2tp_print(netdissect_options *ndo, const u_char *dat, u_int length)
                }
        } else {
                ND_PRINT((ndo, " {"));
                }
        } else {
                ND_PRINT((ndo, " {"));

-               ppp_print(ptr, length - cnt);
+               ppp_print(ndo, ptr, length - cnt);

                ND_PRINT((ndo, "}"));
        }
 
                ND_PRINT((ndo, "}"));
        }
 

diff --git a/print-lldp.c b/print-lldp.c
index f569da1eb364251f74155d594d3cb9ef3894e392..1b7369196ae4e413655b4fefbc607628e30b6b82 100644 (file)
--- a/print-lldp.c
+++ b/print-lldp.c
@@ -19,6 +19,7 @@
  * DCBX extensions by Kaladhar Musunuru <[email protected]>
  */
 
  * DCBX extensions by Kaladhar Musunuru <[email protected]>
  */
 

+#define NETDISSECT_REWORKED

 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif


@@ -26,8 +27,6 @@
 #include <tcpdump-stdinc.h>
 
 #include <stdio.h>
 #include <tcpdump-stdinc.h>
 
 #include <stdio.h>

-#include <stdlib.h>
-#include <string.h>

 
 #include "interface.h"
 #include "extract.h"
 
 #include "interface.h"
 #include "extract.h"


@@ -603,36 +602,43 @@ static const struct tok lldp_evb_mode_values[]={
 #define LLDP_PRIVATE_8021_SUBTYPE_EVB_LENGTH                      9
 #define LLDP_PRIVATE_8021_SUBTYPE_CDCP_MIN_LENGTH                 8
 
 #define LLDP_PRIVATE_8021_SUBTYPE_EVB_LENGTH                      9
 #define LLDP_PRIVATE_8021_SUBTYPE_CDCP_MIN_LENGTH                 8
 

-static void print_ets_priority_assignment_table(const u_char *ptr)
+static void
+print_ets_priority_assignment_table(netdissect_options *ndo,
+                                    const u_char *ptr)

 {
 {

-    printf("\n\t    Priority Assignment Table");
-    printf("\n\t     Priority : 0   1   2   3   4   5   6   7");
-    printf("\n\t     Value    : %-3d %-3d %-3d %-3d %-3d %-3d %-3d %-3d",
+    ND_PRINT((ndo, "\n\t    Priority Assignment Table"));
+    ND_PRINT((ndo, "\n\t     Priority : 0   1   2   3   4   5   6   7"));
+    ND_PRINT((ndo, "\n\t     Value    : %-3d %-3d %-3d %-3d %-3d %-3d %-3d %-3d",

             ptr[0]>>4,ptr[0]&0x0f,ptr[1]>>4,ptr[1]&0x0f,ptr[2]>>4,
             ptr[0]>>4,ptr[0]&0x0f,ptr[1]>>4,ptr[1]&0x0f,ptr[2]>>4,

-            ptr[2]&0x0f,ptr[3]>>4,ptr[3]&0x0f);
+            ptr[2] & 0x0f, ptr[3] >> 4, ptr[3] & 0x0f));

 }
 
 }
 

-static void print_tc_bandwidth_table(const u_char *ptr)
+static void
+print_tc_bandwidth_table(netdissect_options *ndo,
+                         const u_char *ptr)

 {
 {

-    printf("\n\t    TC Bandwidth Table");
-    printf("\n\t     TC%%   : 0   1   2   3   4   5   6   7");
-    printf("\n\t     Value : %-3d %-3d %-3d %-3d %-3d %-3d %-3d %-3d",
-             ptr[0],ptr[1],ptr[2],ptr[3],ptr[4],ptr[5],ptr[6],ptr[7]);
+    ND_PRINT((ndo, "\n\t    TC Bandwidth Table"));
+    ND_PRINT((ndo, "\n\t     TC%%   : 0   1   2   3   4   5   6   7"));
+    ND_PRINT((ndo, "\n\t     Value : %-3d %-3d %-3d %-3d %-3d %-3d %-3d %-3d",
+             ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7]));

 }
 
 }
 

-static void print_tsa_assignment_table(const u_char *ptr)
+static void
+print_tsa_assignment_table(netdissect_options *ndo,
+                           const u_char *ptr)

 {
 {

-    printf("\n\t    TSA Assignment Table");
-    printf("\n\t     Traffic Class: 0   1   2   3   4   5   6   7");
-    printf("\n\t     Value        : %-3d %-3d %-3d %-3d %-3d %-3d %-3d %-3d",
-             ptr[0],ptr[1],ptr[2],ptr[3],ptr[4],ptr[5],ptr[6],ptr[7]);
+    ND_PRINT((ndo, "\n\t    TSA Assignment Table"));
+    ND_PRINT((ndo, "\n\t     Traffic Class: 0   1   2   3   4   5   6   7"));
+    ND_PRINT((ndo, "\n\t     Value        : %-3d %-3d %-3d %-3d %-3d %-3d %-3d %-3d",
+             ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7]));

 }
 
 /*
  * Print IEEE 802.1 private extensions. (802.1AB annex E)
  */
 static int
 }
 
 /*
  * Print IEEE 802.1 private extensions. (802.1AB annex E)
  */
 static int

-lldp_private_8021_print(const u_char *tptr, u_int tlv_len)
+lldp_private_8021_print(netdissect_options *ndo,
+                        const u_char *tptr, u_int tlv_len)

 {
     int subtype, hexdump = FALSE;
     u_int sublen;
 {
     int subtype, hexdump = FALSE;
     u_int sublen;


@@ -644,33 +650,32 @@ lldp_private_8021_print(const u_char *tptr, u_int tlv_len)
     }
     subtype = *(tptr+3);
 
     }
     subtype = *(tptr+3);
 

-    printf("\n\t  %s Subtype (%u)",
+    ND_PRINT((ndo, "\n\t  %s Subtype (%u)",

            tok2str(lldp_8021_subtype_values, "unknown", subtype),
            tok2str(lldp_8021_subtype_values, "unknown", subtype),

-           subtype);
+           subtype));

 
     switch (subtype) {
     case LLDP_PRIVATE_8021_SUBTYPE_PORT_VLAN_ID:
         if (tlv_len < 6) {
             return hexdump;
         }
 
     switch (subtype) {
     case LLDP_PRIVATE_8021_SUBTYPE_PORT_VLAN_ID:
         if (tlv_len < 6) {
             return hexdump;
         }

-        printf("\n\t    port vlan id (PVID): %u",
-               EXTRACT_16BITS(tptr+4));
+        ND_PRINT((ndo, "\n\t    port vlan id (PVID): %u",
+               EXTRACT_16BITS(tptr + 4)));

         break;
     case LLDP_PRIVATE_8021_SUBTYPE_PROTOCOL_VLAN_ID:
         if (tlv_len < 7) {
             return hexdump;
         }
         break;
     case LLDP_PRIVATE_8021_SUBTYPE_PROTOCOL_VLAN_ID:
         if (tlv_len < 7) {
             return hexdump;
         }

-        printf("\n\t    port and protocol vlan id (PPVID): %u, flags [%s] (0x%02x)",
+        ND_PRINT((ndo, "\n\t    port and protocol vlan id (PPVID): %u, flags [%s] (0x%02x)",

                EXTRACT_16BITS(tptr+5),
               bittok2str(lldp_8021_port_protocol_id_values, "none", *(tptr+4)),
                EXTRACT_16BITS(tptr+5),
               bittok2str(lldp_8021_port_protocol_id_values, "none", *(tptr+4)),

-              *(tptr+4));
+              *(tptr + 4)));

         break;
     case LLDP_PRIVATE_8021_SUBTYPE_VLAN_NAME:
         if (tlv_len < 6) {
             return hexdump;
         }
         break;
     case LLDP_PRIVATE_8021_SUBTYPE_VLAN_NAME:
         if (tlv_len < 6) {
             return hexdump;
         }

-        printf("\n\t    vlan id (VID): %u",
-               EXTRACT_16BITS(tptr+4));
+        ND_PRINT((ndo, "\n\t    vlan id (VID): %u", EXTRACT_16BITS(tptr + 4)));

         if (tlv_len < 7) {
             return hexdump;
         }
         if (tlv_len < 7) {
             return hexdump;
         }


@@ -678,8 +683,8 @@ lldp_private_8021_print(const u_char *tptr, u_int tlv_len)
         if (tlv_len < 7+sublen) {
             return hexdump;
         }
         if (tlv_len < 7+sublen) {
             return hexdump;
         }

-        printf("\n\t    vlan name: ");
-        safeputs(gndo, tptr + 7, sublen);
+        ND_PRINT((ndo, "\n\t    vlan name: "));
+        safeputs(ndo, tptr + 7, sublen);

         break;
     case LLDP_PRIVATE_8021_SUBTYPE_PROTOCOL_IDENTITY:
         if (tlv_len < 5) {
         break;
     case LLDP_PRIVATE_8021_SUBTYPE_PROTOCOL_IDENTITY:
         if (tlv_len < 5) {


@@ -689,25 +694,25 @@ lldp_private_8021_print(const u_char *tptr, u_int tlv_len)
         if (tlv_len < 5+sublen) {
             return hexdump;
         }
         if (tlv_len < 5+sublen) {
             return hexdump;
         }

-        printf("\n\t    protocol identity: ");
-        safeputs(gndo, tptr + 5, sublen);
+        ND_PRINT((ndo, "\n\t    protocol identity: "));
+        safeputs(ndo, tptr + 5, sublen);

         break;
     case LLDP_PRIVATE_8021_SUBTYPE_CONGESTION_NOTIFICATION:
         if(tlv_len<LLDP_PRIVATE_8021_SUBTYPE_CONGESTION_NOTIFICATION_LENGTH){
                return hexdump;
         }
         tval=*(tptr+4);
         break;
     case LLDP_PRIVATE_8021_SUBTYPE_CONGESTION_NOTIFICATION:
         if(tlv_len<LLDP_PRIVATE_8021_SUBTYPE_CONGESTION_NOTIFICATION_LENGTH){
                return hexdump;
         }
         tval=*(tptr+4);

-        printf("\n\t    Pre-Priority CNPV Indicator");
-        printf("\n\t     Priority : 0  1  2  3  4  5  6  7");
-        printf("\n\t     Value    : ");
+        ND_PRINT((ndo, "\n\t    Pre-Priority CNPV Indicator"));
+        ND_PRINT((ndo, "\n\t     Priority : 0  1  2  3  4  5  6  7"));
+        ND_PRINT((ndo, "\n\t     Value    : "));

         for(i=0;i<NO_OF_BITS;i++)
         for(i=0;i<NO_OF_BITS;i++)

-            printf("%-2d ",(tval>>i)&0x01);
+            ND_PRINT((ndo, "%-2d ", (tval >> i) & 0x01));

         tval=*(tptr+5);
         tval=*(tptr+5);

-        printf("\n\t    Pre-Priority Ready Indicator");
-        printf("\n\t     Priority : 0  1  2  3  4  5  6  7");
-        printf("\n\t     Value    : ");
+        ND_PRINT((ndo, "\n\t    Pre-Priority Ready Indicator"));
+        ND_PRINT((ndo, "\n\t     Priority : 0  1  2  3  4  5  6  7"));
+        ND_PRINT((ndo, "\n\t     Value    : "));

         for(i=0;i<NO_OF_BITS;i++)
         for(i=0;i<NO_OF_BITS;i++)

-            printf("%-2d ",(tval>>i)&0x01);
+            ND_PRINT((ndo, "%-2d ", (tval >> i) & 0x01));

         break;
 
     case LLDP_PRIVATE_8021_SUBTYPE_ETS_CONFIGURATION:
         break;
 
     case LLDP_PRIVATE_8021_SUBTYPE_ETS_CONFIGURATION:


@@ -715,17 +720,17 @@ lldp_private_8021_print(const u_char *tptr, u_int tlv_len)
             return hexdump;
         }
         tval=*(tptr+4);
             return hexdump;
         }
         tval=*(tptr+4);

-        printf("\n\t    Willing:%d, CBS:%d, RES:%d, Max TCs:%d",
-               tval>>7, (tval>>6) & 0x02, (tval>>3) & 0x07, tval & 0x07);
+        ND_PRINT((ndo, "\n\t    Willing:%d, CBS:%d, RES:%d, Max TCs:%d",
+               tval >> 7, (tval >> 6) & 0x02, (tval >> 3) & 0x07, tval & 0x07));

 
         /*Print Priority Assignment Table*/
 
         /*Print Priority Assignment Table*/

-        print_ets_priority_assignment_table(tptr+5);
+        print_ets_priority_assignment_table(ndo, tptr + 5);

 
         /*Print TC Bandwidth Table*/
 
         /*Print TC Bandwidth Table*/

-        print_tc_bandwidth_table(tptr+9);
+        print_tc_bandwidth_table(ndo, tptr + 9);

 
         /* Print TSA Assignment Table */
 
         /* Print TSA Assignment Table */

-        print_tsa_assignment_table(tptr+17);
+        print_tsa_assignment_table(ndo, tptr + 17);

 
         break;
 
 
         break;
 


@@ -733,13 +738,13 @@ lldp_private_8021_print(const u_char *tptr, u_int tlv_len)
         if(tlv_len<LLDP_PRIVATE_8021_SUBTYPE_ETS_RECOMMENDATION_LENGTH) {
                return hexdump;
         }
         if(tlv_len<LLDP_PRIVATE_8021_SUBTYPE_ETS_RECOMMENDATION_LENGTH) {
                return hexdump;
         }

-        printf("\n\t    RES: %d",*(tptr+4));
+        ND_PRINT((ndo, "\n\t    RES: %d", *(tptr + 4)));

         /*Print Priority Assignment Table */
         /*Print Priority Assignment Table */

-        print_ets_priority_assignment_table(tptr+5);
+        print_ets_priority_assignment_table(ndo, tptr + 5);

         /*Print TC Bandwidth Table */
         /*Print TC Bandwidth Table */

-        print_tc_bandwidth_table(tptr+9);
+        print_tc_bandwidth_table(ndo, tptr + 9);

         /* Print TSA Assignment Table */
         /* Print TSA Assignment Table */

-        print_tsa_assignment_table(tptr+17);
+        print_tsa_assignment_table(ndo, tptr + 17);

         break;
 
     case LLDP_PRIVATE_8021_SUBTYPE_PFC_CONFIGURATION:
         break;
 
     case LLDP_PRIVATE_8021_SUBTYPE_PFC_CONFIGURATION:


@@ -747,21 +752,21 @@ lldp_private_8021_print(const u_char *tptr, u_int tlv_len)
             return hexdump;
         }
         tval=*(tptr+4);
             return hexdump;
         }
         tval=*(tptr+4);

-        printf("\n\t    Willing: %d, MBC: %d, RES: %d, PFC cap:%d ",
-               tval>>7, (tval>>6)&0x01, (tval>>4)&0x03, (tval & 0x0f));
-        printf("\n\t    PFC Enable");
+        ND_PRINT((ndo, "\n\t    Willing: %d, MBC: %d, RES: %d, PFC cap:%d ",
+               tval >> 7, (tval >> 6) & 0x01, (tval >> 4) & 0x03, (tval & 0x0f)));
+        ND_PRINT((ndo, "\n\t    PFC Enable"));

         tval=*(tptr+5);
         tval=*(tptr+5);

-        printf("\n\t     Priority : 0  1  2  3  4  5  6  7");
-        printf("\n\t     Value    : ");
+        ND_PRINT((ndo, "\n\t     Priority : 0  1  2  3  4  5  6  7"));
+        ND_PRINT((ndo, "\n\t     Value    : "));

         for(i=0;i<NO_OF_BITS;i++)
         for(i=0;i<NO_OF_BITS;i++)

-            printf("%-2d ",(tval>>i)&0x01);
+            ND_PRINT((ndo, "%-2d ", (tval >> i) & 0x01));

         break;
 
     case LLDP_PRIVATE_8021_SUBTYPE_APPLICATION_PRIORITY:
         if(tlv_len<LLDP_PRIVATE_8021_SUBTYPE_APPLICATION_PRIORITY_MIN_LENGTH) {
             return hexdump;
         }
         break;
 
     case LLDP_PRIVATE_8021_SUBTYPE_APPLICATION_PRIORITY:
         if(tlv_len<LLDP_PRIVATE_8021_SUBTYPE_APPLICATION_PRIORITY_MIN_LENGTH) {
             return hexdump;
         }

-        printf("\n\t    RES: %d",*(tptr+4));
+        ND_PRINT((ndo, "\n\t    RES: %d", *(tptr + 4)));

         if(tlv_len<=LLDP_PRIVATE_8021_SUBTYPE_APPLICATION_PRIORITY_MIN_LENGTH){
                return hexdump;
         }
         if(tlv_len<=LLDP_PRIVATE_8021_SUBTYPE_APPLICATION_PRIORITY_MIN_LENGTH){
                return hexdump;
         }


@@ -771,12 +776,12 @@ lldp_private_8021_print(const u_char *tptr, u_int tlv_len)
                return hexdump;
         }
         i=0;
                return hexdump;
         }
         i=0;

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

         while(i<sublen) {
                tval=*(tptr+i+5);
         while(i<sublen) {
                tval=*(tptr+i+5);

-               printf("\n\t      Priority: %d, RES: %d, Sel: %d",
-                        tval>>5, (tval>>3)&0x03, (tval & 0x07));
-               printf("Protocol ID: %d",EXTRACT_16BITS(tptr+i+5));
+               ND_PRINT((ndo, "\n\t      Priority: %d, RES: %d, Sel: %d",
+                        tval >> 5, (tval >> 3) & 0x03, (tval & 0x07)));
+               ND_PRINT((ndo, "Protocol ID: %d", EXTRACT_16BITS(tptr + i + 5)));

                i=i+3;
         }
         break;
                i=i+3;
         }
         break;


@@ -784,22 +789,22 @@ lldp_private_8021_print(const u_char *tptr, u_int tlv_len)
         if(tlv_len<LLDP_PRIVATE_8021_SUBTYPE_EVB_LENGTH){
                return hexdump;
         }
         if(tlv_len<LLDP_PRIVATE_8021_SUBTYPE_EVB_LENGTH){
                return hexdump;
         }

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

         tval=*(tptr+4);
         tval=*(tptr+4);

-        printf("\n\t      RES: %d, BGID: %d, RRCAP: %d, RRCTR: %d",
-               tval>>3, (tval>>2)&0x01, (tval>>1)&0x01,tval&0x01);
-        printf("\n\t    EVB Station Status");
+        ND_PRINT((ndo, "\n\t      RES: %d, BGID: %d, RRCAP: %d, RRCTR: %d",
+               tval >> 3, (tval >> 2) & 0x01, (tval >> 1) & 0x01, tval & 0x01));
+        ND_PRINT((ndo, "\n\t    EVB Station Status"));

         tval=*(tptr+5);
         tval=*(tptr+5);

-        printf("\n\t      RES: %d, SGID: %d, RRREQ: %d,RRSTAT: %d",
-               tval>>4, (tval>>3)&0x01, (tval>>2)&0x01, tval&0x03);
+        ND_PRINT((ndo, "\n\t      RES: %d, SGID: %d, RRREQ: %d,RRSTAT: %d",
+               tval >> 4, (tval >> 3) & 0x01, (tval >> 2) & 0x01, tval & 0x03));

         tval=*(tptr+6);
         tval=*(tptr+6);

-        printf("\n\t    R: %d, RTE: %d, ",tval>>5, tval&0x1f);
+        ND_PRINT((ndo, "\n\t    R: %d, RTE: %d, ",tval >> 5, tval & 0x1f));

         tval=*(tptr+7);
         tval=*(tptr+7);

-        printf("EVB Mode: %s [%d]",
-               tok2str(lldp_evb_mode_values,"unknown",tval>>6),tval>>6);
-        printf("\n\t    ROL: %d, RWD: %d, ", (tval>>5)&0x01,tval&0x1f);
+        ND_PRINT((ndo, "EVB Mode: %s [%d]",
+               tok2str(lldp_evb_mode_values, "unknown", tval >> 6), tval >> 6));
+        ND_PRINT((ndo, "\n\t    ROL: %d, RWD: %d, ", (tval >> 5) & 0x01, tval & 0x1f));

         tval=*(tptr+8);
         tval=*(tptr+8);

-        printf("RES: %d, ROL: %d, RKA: %d", tval>>6,(tval>>5)&0x01, tval&0x1f);
+        ND_PRINT((ndo, "RES: %d, ROL: %d, RKA: %d", tval >> 6, (tval >> 5) & 0x01, tval & 0x1f));

         break;
 
     case LLDP_PRIVATE_8021_SUBTYPE_CDCP:
         break;
 
     case LLDP_PRIVATE_8021_SUBTYPE_CDCP:


@@ -807,9 +812,9 @@ lldp_private_8021_print(const u_char *tptr, u_int tlv_len)
                return hexdump;
         }
         tval=*(tptr+4);
                return hexdump;
         }
         tval=*(tptr+4);

-        printf("\n\t    Role: %d, RES: %d, Scomp: %d ",
-               tval>>7, (tval>>4)&0x07,(tval>>3)&0x01);
-        printf("ChnCap: %d",EXTRACT_16BITS(tptr+6)&0x0fff);
+        ND_PRINT((ndo, "\n\t    Role: %d, RES: %d, Scomp: %d ",
+               tval >> 7, (tval >> 4) & 0x07, (tval >> 3) & 0x01));
+        ND_PRINT((ndo, "ChnCap: %d", EXTRACT_16BITS(tptr + 6) & 0x0fff));

         sublen=tlv_len-8;
         if(sublen%3!=0) {
                return hexdump;
         sublen=tlv_len-8;
         if(sublen%3!=0) {
                return hexdump;


@@ -817,8 +822,8 @@ lldp_private_8021_print(const u_char *tptr, u_int tlv_len)
         i=0;
         while(i<sublen) {
                tval=EXTRACT_24BITS(tptr+i+8);
         i=0;
         while(i<sublen) {
                tval=EXTRACT_24BITS(tptr+i+8);

-               printf("\n\t    SCID: %d, SVID: %d",
-                       tval>>12, tval&0x000fff);
+               ND_PRINT((ndo, "\n\t    SCID: %d, SVID: %d",
+                       tval >> 12, tval & 0x000fff));

                i=i+3;
         }
         break;
                i=i+3;
         }
         break;


@@ -835,7 +840,8 @@ lldp_private_8021_print(const u_char *tptr, u_int tlv_len)
  * Print IEEE 802.3 private extensions. (802.3bc)
  */
 static int
  * Print IEEE 802.3 private extensions. (802.3bc)
  */
 static int

-lldp_private_8023_print(const u_char *tptr, u_int tlv_len)
+lldp_private_8023_print(netdissect_options *ndo,
+                        const u_char *tptr, u_int tlv_len)

 {
     int subtype, hexdump = FALSE;
 
 {
     int subtype, hexdump = FALSE;
 


@@ -844,47 +850,47 @@ lldp_private_8023_print(const u_char *tptr, u_int tlv_len)
     }
     subtype = *(tptr+3);
 
     }
     subtype = *(tptr+3);
 

-    printf("\n\t  %s Subtype (%u)",
+    ND_PRINT((ndo, "\n\t  %s Subtype (%u)",

            tok2str(lldp_8023_subtype_values, "unknown", subtype),
            tok2str(lldp_8023_subtype_values, "unknown", subtype),

-           subtype);
+           subtype));

 
     switch (subtype) {
     case LLDP_PRIVATE_8023_SUBTYPE_MACPHY:
         if (tlv_len < 9) {
             return hexdump;
         }
 
     switch (subtype) {
     case LLDP_PRIVATE_8023_SUBTYPE_MACPHY:
         if (tlv_len < 9) {
             return hexdump;
         }

-        printf("\n\t    autonegotiation [%s] (0x%02x)",
+        ND_PRINT((ndo, "\n\t    autonegotiation [%s] (0x%02x)",

                bittok2str(lldp_8023_autonegotiation_values, "none", *(tptr+4)),
                bittok2str(lldp_8023_autonegotiation_values, "none", *(tptr+4)),

-               *(tptr+4));
-        printf("\n\t    PMD autoneg capability [%s] (0x%04x)",
+               *(tptr + 4)));
+        ND_PRINT((ndo, "\n\t    PMD autoneg capability [%s] (0x%04x)",

                bittok2str(lldp_pmd_capability_values,"unknown", EXTRACT_16BITS(tptr+5)),
                bittok2str(lldp_pmd_capability_values,"unknown", EXTRACT_16BITS(tptr+5)),

-               EXTRACT_16BITS(tptr+5));
-        printf("\n\t    MAU type %s (0x%04x)",
+               EXTRACT_16BITS(tptr + 5)));
+        ND_PRINT((ndo, "\n\t    MAU type %s (0x%04x)",

                tok2str(lldp_mau_types_values, "unknown", EXTRACT_16BITS(tptr+7)),
                tok2str(lldp_mau_types_values, "unknown", EXTRACT_16BITS(tptr+7)),

-               EXTRACT_16BITS(tptr+7));
+               EXTRACT_16BITS(tptr + 7)));

         break;
 
     case LLDP_PRIVATE_8023_SUBTYPE_MDIPOWER:
         if (tlv_len < 7) {
             return hexdump;
         }
         break;
 
     case LLDP_PRIVATE_8023_SUBTYPE_MDIPOWER:
         if (tlv_len < 7) {
             return hexdump;
         }

-        printf("\n\t    MDI power support [%s], power pair %s, power class %s",
+        ND_PRINT((ndo, "\n\t    MDI power support [%s], power pair %s, power class %s",

                bittok2str(lldp_mdi_values, "none", *(tptr+4)),
                tok2str(lldp_mdi_power_pairs_values, "unknown", *(tptr+5)),
                bittok2str(lldp_mdi_values, "none", *(tptr+4)),
                tok2str(lldp_mdi_power_pairs_values, "unknown", *(tptr+5)),

-               tok2str(lldp_mdi_power_class_values, "unknown", *(tptr+6)));
+               tok2str(lldp_mdi_power_class_values, "unknown", *(tptr + 6))));

         break;
 
     case LLDP_PRIVATE_8023_SUBTYPE_LINKAGGR:
         if (tlv_len < 9) {
             return hexdump;
         }
         break;
 
     case LLDP_PRIVATE_8023_SUBTYPE_LINKAGGR:
         if (tlv_len < 9) {
             return hexdump;
         }

-        printf("\n\t    aggregation status [%s], aggregation port ID %u",
+        ND_PRINT((ndo, "\n\t    aggregation status [%s], aggregation port ID %u",

                bittok2str(lldp_aggregation_values, "none", *(tptr+4)),
                bittok2str(lldp_aggregation_values, "none", *(tptr+4)),

-               EXTRACT_32BITS(tptr+5));
+               EXTRACT_32BITS(tptr + 5)));

         break;
 
     case LLDP_PRIVATE_8023_SUBTYPE_MTU:
         break;
 
     case LLDP_PRIVATE_8023_SUBTYPE_MTU:

-        printf("\n\t    MTU size %u", EXTRACT_16BITS(tptr+4));
+        ND_PRINT((ndo, "\n\t    MTU size %u", EXTRACT_16BITS(tptr + 4)));

         break;
 
     default:
         break;
 
     default:


@@ -913,7 +919,8 @@ lldp_extract_latlon(const u_char *tptr)
  * Print private TIA extensions.
  */
 static int
  * Print private TIA extensions.
  */
 static int

-lldp_private_tia_print(const u_char *tptr, u_int tlv_len)
+lldp_private_tia_print(netdissect_options *ndo,
+                       const u_char *tptr, u_int tlv_len)

 {
     int subtype, hexdump = FALSE;
     u_int8_t location_format;
 {
     int subtype, hexdump = FALSE;
     u_int8_t location_format;


@@ -926,38 +933,38 @@ lldp_private_tia_print(const u_char *tptr, u_int tlv_len)
     }
     subtype = *(tptr+3);
 
     }
     subtype = *(tptr+3);
 

-    printf("\n\t  %s Subtype (%u)",
+    ND_PRINT((ndo, "\n\t  %s Subtype (%u)",

            tok2str(lldp_tia_subtype_values, "unknown", subtype),
            tok2str(lldp_tia_subtype_values, "unknown", subtype),

-           subtype);
+           subtype));

 
     switch (subtype) {
     case LLDP_PRIVATE_TIA_SUBTYPE_CAPABILITIES:
         if (tlv_len < 7) {
             return hexdump;
         }
 
     switch (subtype) {
     case LLDP_PRIVATE_TIA_SUBTYPE_CAPABILITIES:
         if (tlv_len < 7) {
             return hexdump;
         }

-        printf("\n\t    Media capabilities [%s] (0x%04x)",
+        ND_PRINT((ndo, "\n\t    Media capabilities [%s] (0x%04x)",

                bittok2str(lldp_tia_capabilities_values, "none",
                bittok2str(lldp_tia_capabilities_values, "none",

-                          EXTRACT_16BITS(tptr+4)), EXTRACT_16BITS(tptr+4));
-        printf("\n\t    Device type [%s] (0x%02x)",
+                          EXTRACT_16BITS(tptr + 4)), EXTRACT_16BITS(tptr + 4)));
+        ND_PRINT((ndo, "\n\t    Device type [%s] (0x%02x)",

                tok2str(lldp_tia_device_type_values, "unknown", *(tptr+6)),
                tok2str(lldp_tia_device_type_values, "unknown", *(tptr+6)),

-               *(tptr+6));
+               *(tptr + 6)));

         break;
 
     case LLDP_PRIVATE_TIA_SUBTYPE_NETWORK_POLICY:
         if (tlv_len < 8) {
             return hexdump;
         }
         break;
 
     case LLDP_PRIVATE_TIA_SUBTYPE_NETWORK_POLICY:
         if (tlv_len < 8) {
             return hexdump;
         }

-        printf("\n\t    Application type [%s] (0x%02x)",
+        ND_PRINT((ndo, "\n\t    Application type [%s] (0x%02x)",

                tok2str(lldp_tia_application_type_values, "none", *(tptr+4)),
                tok2str(lldp_tia_application_type_values, "none", *(tptr+4)),

-               *(tptr+4));
-        printf(", Flags [%s]", bittok2str(
-                   lldp_tia_network_policy_bits_values, "none", *(tptr+5)));
-        printf("\n\t    Vlan id %u",
-               LLDP_EXTRACT_NETWORK_POLICY_VLAN(EXTRACT_16BITS(tptr+5)));
-        printf(", L2 priority %u",
-               LLDP_EXTRACT_NETWORK_POLICY_L2_PRIORITY(EXTRACT_16BITS(tptr+6)));
-        printf(", DSCP value %u",
-               LLDP_EXTRACT_NETWORK_POLICY_DSCP(EXTRACT_16BITS(tptr+6)));
+               *(tptr + 4)));
+        ND_PRINT((ndo, ", Flags [%s]", bittok2str(
+                   lldp_tia_network_policy_bits_values, "none", *(tptr + 5))));
+        ND_PRINT((ndo, "\n\t    Vlan id %u",
+               LLDP_EXTRACT_NETWORK_POLICY_VLAN(EXTRACT_16BITS(tptr + 5))));
+        ND_PRINT((ndo, ", L2 priority %u",
+               LLDP_EXTRACT_NETWORK_POLICY_L2_PRIORITY(EXTRACT_16BITS(tptr + 6))));
+        ND_PRINT((ndo, ", DSCP value %u",
+               LLDP_EXTRACT_NETWORK_POLICY_DSCP(EXTRACT_16BITS(tptr + 6))));

         break;
 
     case LLDP_PRIVATE_TIA_SUBTYPE_LOCAL_ID:
         break;
 
     case LLDP_PRIVATE_TIA_SUBTYPE_LOCAL_ID:


@@ -965,28 +972,28 @@ lldp_private_tia_print(const u_char *tptr, u_int tlv_len)
             return hexdump;
         }
         location_format = *(tptr+4);
             return hexdump;
         }
         location_format = *(tptr+4);

-        printf("\n\t    Location data format %s (0x%02x)",
+        ND_PRINT((ndo, "\n\t    Location data format %s (0x%02x)",

                tok2str(lldp_tia_location_data_format_values, "unknown", location_format),
                tok2str(lldp_tia_location_data_format_values, "unknown", location_format),

-               location_format);
+               location_format));

 
         switch (location_format) {
         case LLDP_TIA_LOCATION_DATA_FORMAT_COORDINATE_BASED:
             if (tlv_len < 21) {
                 return hexdump;
             }
 
         switch (location_format) {
         case LLDP_TIA_LOCATION_DATA_FORMAT_COORDINATE_BASED:
             if (tlv_len < 21) {
                 return hexdump;
             }

-            printf("\n\t    Latitude resolution %u, latitude value %" PRIu64,
-                   (*(tptr+5)>>2), lldp_extract_latlon(tptr+5));
-            printf("\n\t    Longitude resolution %u, longitude value %" PRIu64,
-                   (*(tptr+10)>>2), lldp_extract_latlon(tptr+10));
-            printf("\n\t    Altitude type %s (%u)",
+            ND_PRINT((ndo, "\n\t    Latitude resolution %u, latitude value %" PRIu64,
+                   (*(tptr + 5) >> 2), lldp_extract_latlon(tptr + 5)));
+            ND_PRINT((ndo, "\n\t    Longitude resolution %u, longitude value %" PRIu64,
+                   (*(tptr + 10) >> 2), lldp_extract_latlon(tptr + 10)));
+            ND_PRINT((ndo, "\n\t    Altitude type %s (%u)",

                    tok2str(lldp_tia_location_altitude_type_values, "unknown",(*(tptr+15)>>4)),
                    tok2str(lldp_tia_location_altitude_type_values, "unknown",(*(tptr+15)>>4)),

-                   (*(tptr+15)>>4));
-            printf("\n\t    Altitude resolution %u, altitude value 0x%x",
+                   (*(tptr + 15) >> 4)));
+            ND_PRINT((ndo, "\n\t    Altitude resolution %u, altitude value 0x%x",

                    (EXTRACT_16BITS(tptr+15)>>6)&0x3f,
                    (EXTRACT_16BITS(tptr+15)>>6)&0x3f,

-                   ((EXTRACT_32BITS(tptr+16)&0x3fffffff)));
-            printf("\n\t    Datum %s (0x%02x)",
+                   ((EXTRACT_32BITS(tptr + 16) & 0x3fffffff))));
+            ND_PRINT((ndo, "\n\t    Datum %s (0x%02x)",

                    tok2str(lldp_tia_location_datum_type_values, "unknown", *(tptr+20)),
                    tok2str(lldp_tia_location_datum_type_values, "unknown", *(tptr+20)),

-                   *(tptr+20));
+                   *(tptr + 20)));

             break;
 
         case LLDP_TIA_LOCATION_DATA_FORMAT_CIVIC_ADDRESS:
             break;
 
         case LLDP_TIA_LOCATION_DATA_FORMAT_CIVIC_ADDRESS:


@@ -1000,13 +1007,13 @@ lldp_private_tia_print(const u_char *tptr, u_int tlv_len)
             if (tlv_len < 7+lci_len) {
                 return hexdump;
             }
             if (tlv_len < 7+lci_len) {
                 return hexdump;
             }

-            printf("\n\t    LCI length %u, LCI what %s (0x%02x), Country-code ",
+            ND_PRINT((ndo, "\n\t    LCI length %u, LCI what %s (0x%02x), Country-code ",

                    lci_len,
                    tok2str(lldp_tia_location_lci_what_values, "unknown", *(tptr+6)),
                    lci_len,
                    tok2str(lldp_tia_location_lci_what_values, "unknown", *(tptr+6)),

-                   *(tptr+6));
+                   *(tptr + 6)));

 
             /* Country code */
 
             /* Country code */

-            safeputs(gndo, tptr + 7, 2);
+            safeputs(ndo, tptr + 7, 2);

 
             lci_len = lci_len-3;
             tptr = tptr + 9;
 
             lci_len = lci_len-3;
             tptr = tptr + 9;


@@ -1022,9 +1029,9 @@ lldp_private_tia_print(const u_char *tptr, u_int tlv_len)
                tptr += 2;
                 lci_len -= 2;
 
                tptr += 2;
                 lci_len -= 2;
 

-                printf("\n\t      CA type \'%s\' (%u), length %u: ",
+                ND_PRINT((ndo, "\n\t      CA type \'%s\' (%u), length %u: ",

                        tok2str(lldp_tia_location_lci_catype_values, "unknown", ca_type),
                        tok2str(lldp_tia_location_lci_catype_values, "unknown", ca_type),

-                       ca_type, ca_len);
+                       ca_type, ca_len));

 
                /* basic sanity check */
                if ( ca_type == 0 || ca_len == 0) {
 
                /* basic sanity check */
                if ( ca_type == 0 || ca_len == 0) {


@@ -1034,20 +1041,20 @@ lldp_private_tia_print(const u_char *tptr, u_int tlv_len)
                    return hexdump;
                }
 
                    return hexdump;
                }
 

-                safeputs(gndo, tptr, ca_len);
+                safeputs(ndo, tptr, ca_len);

                 tptr += ca_len;
                 lci_len -= ca_len;
             }
             break;
 
         case LLDP_TIA_LOCATION_DATA_FORMAT_ECS_ELIN:
                 tptr += ca_len;
                 lci_len -= ca_len;
             }
             break;
 
         case LLDP_TIA_LOCATION_DATA_FORMAT_ECS_ELIN:

-            printf("\n\t    ECS ELIN id ");
-            safeputs(gndo, tptr + 5, tlv_len - 5);
+            ND_PRINT((ndo, "\n\t    ECS ELIN id "));
+            safeputs(ndo, tptr + 5, tlv_len - 5);

             break;
 
         default:
             break;
 
         default:

-            printf("\n\t    Location ID ");
-            print_unknown_data(gndo,tptr+5, "\n\t      ", tlv_len-5);
+            ND_PRINT((ndo, "\n\t    Location ID "));
+            print_unknown_data(ndo, tptr + 5, "\n\t      ", tlv_len - 5);

         }
         break;
 
         }
         break;
 


@@ -1055,18 +1062,18 @@ lldp_private_tia_print(const u_char *tptr, u_int tlv_len)
         if (tlv_len < 7) {
             return hexdump;
         }
         if (tlv_len < 7) {
             return hexdump;
         }

-        printf("\n\t    Power type [%s]",
-               (*(tptr+4)&0xC0>>6) ? "PD device" : "PSE device");
-        printf(", Power source [%s]",
-               tok2str(lldp_tia_power_source_values, "none", (*(tptr+4)&0x30)>>4));
-        printf("\n\t    Power priority [%s] (0x%02x)",
+        ND_PRINT((ndo, "\n\t    Power type [%s]",
+               (*(tptr + 4) & 0xC0 >> 6) ? "PD device" : "PSE device"));
+        ND_PRINT((ndo, ", Power source [%s]",
+               tok2str(lldp_tia_power_source_values, "none", (*(tptr + 4) & 0x30) >> 4)));
+        ND_PRINT((ndo, "\n\t    Power priority [%s] (0x%02x)",

                tok2str(lldp_tia_power_priority_values, "none", *(tptr+4)&0x0f),
                tok2str(lldp_tia_power_priority_values, "none", *(tptr+4)&0x0f),

-               *(tptr+4)&0x0f);
+               *(tptr + 4) & 0x0f));

         power_val = EXTRACT_16BITS(tptr+5);
         if (power_val < LLDP_TIA_POWER_VAL_MAX) {
         power_val = EXTRACT_16BITS(tptr+5);
         if (power_val < LLDP_TIA_POWER_VAL_MAX) {

-            printf(", Power %.1f Watts", ((float)power_val)/10);
+            ND_PRINT((ndo, ", Power %.1f Watts", ((float)power_val) / 10));

         } else {
         } else {

-            printf(", Power %u (Reserved)", power_val);
+            ND_PRINT((ndo, ", Power %u (Reserved)", power_val));

         }
         break;
 
         }
         break;
 


@@ -1077,9 +1084,9 @@ lldp_private_tia_print(const u_char *tptr, u_int tlv_len)
     case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_MANUFACTURER_NAME:
     case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_MODEL_NAME:
     case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_ASSET_ID:
     case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_MANUFACTURER_NAME:
     case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_MODEL_NAME:
     case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_ASSET_ID:

-        printf("\n\t  %s ",
-               tok2str(lldp_tia_inventory_values, "unknown", subtype));
-        safeputs(gndo, tptr + 4, tlv_len - 4);
+        ND_PRINT((ndo, "\n\t  %s ",
+               tok2str(lldp_tia_inventory_values, "unknown", subtype)));
+        safeputs(ndo, tptr + 4, tlv_len - 4);

         break;
 
     default:
         break;
 
     default:


@@ -1094,7 +1101,8 @@ lldp_private_tia_print(const u_char *tptr, u_int tlv_len)
  * Print DCBX Protocol fields (V 1.01).
  */
 static int
  * Print DCBX Protocol fields (V 1.01).
  */
 static int

-lldp_private_dcbx_print(const u_char *pptr, u_int len)
+lldp_private_dcbx_print(netdissect_options *ndo,
+                        const u_char *pptr, u_int len)

 {
     int subtype, hexdump = FALSE;
     u_int8_t tval;
 {
     int subtype, hexdump = FALSE;
     u_int8_t tval;


@@ -1108,9 +1116,9 @@ lldp_private_dcbx_print(const u_char *pptr, u_int len)
     }
     subtype = *(pptr+3);
 
     }
     subtype = *(pptr+3);
 

-    printf("\n\t  %s Subtype (%u)",
+    ND_PRINT((ndo, "\n\t  %s Subtype (%u)",

            tok2str(lldp_dcbx_subtype_values, "unknown", subtype),
            tok2str(lldp_dcbx_subtype_values, "unknown", subtype),

-           subtype);
+           subtype));

 
     /* by passing old version */
     if (subtype == LLDP_DCBX_SUBTYPE_1)
 
     /* by passing old version */
     if (subtype == LLDP_DCBX_SUBTYPE_1)


@@ -1121,7 +1129,7 @@ lldp_private_dcbx_print(const u_char *pptr, u_int len)
 
     while (tlen >= sizeof(tlv)) {
 
 
     while (tlen >= sizeof(tlv)) {
 

-        TCHECK2(*tptr, sizeof(tlv));
+        ND_TCHECK2(*tptr, sizeof(tlv));

 
         tlv = EXTRACT_16BITS(tptr);
 
 
         tlv = EXTRACT_16BITS(tptr);
 


@@ -1137,7 +1145,7 @@ lldp_private_dcbx_print(const u_char *pptr, u_int len)
             break;
         }
 
             break;
         }
 

-        TCHECK2(*tptr, tlv_len);
+        ND_TCHECK2(*tptr, tlv_len);

         if (tlen < tlv_len) {
             goto trunc;
         }
         if (tlen < tlv_len) {
             goto trunc;
         }


@@ -1148,89 +1156,89 @@ lldp_private_dcbx_print(const u_char *pptr, u_int len)
             if (tlv_len < 10) {
                 goto trunc;
             }
             if (tlv_len < 10) {
                 goto trunc;
             }

-           printf("\n\t    Control - Protocol Control (type 0x%x, length %d)",
-               LLDP_DCBX_CONTROL_TLV, tlv_len);
-           printf("\n\t      Oper_Version: %d", *tptr);
-           printf("\n\t      Max_Version: %d", *(tptr+1));
-           printf("\n\t      Sequence Number: %d", EXTRACT_32BITS(tptr+2));
-           printf("\n\t      Acknowledgement Number: %d",
-                                       EXTRACT_32BITS(tptr+6));
+           ND_PRINT((ndo, "\n\t    Control - Protocol Control (type 0x%x, length %d)",
+               LLDP_DCBX_CONTROL_TLV, tlv_len));
+           ND_PRINT((ndo, "\n\t      Oper_Version: %d", *tptr));
+           ND_PRINT((ndo, "\n\t      Max_Version: %d", *(tptr + 1)));
+           ND_PRINT((ndo, "\n\t      Sequence Number: %d", EXTRACT_32BITS(tptr + 2)));
+           ND_PRINT((ndo, "\n\t      Acknowledgement Number: %d",
+                                       EXTRACT_32BITS(tptr + 6)));

            break;
         case LLDP_DCBX_PRIORITY_GROUPS_TLV:
             if (tlv_len < 17) {
                 goto trunc;
             }
            break;
         case LLDP_DCBX_PRIORITY_GROUPS_TLV:
             if (tlv_len < 17) {
                 goto trunc;
             }

-           printf("\n\t    Feature - Priority Group (type 0x%x, length %d)",
-               LLDP_DCBX_PRIORITY_GROUPS_TLV, tlv_len);
-           printf("\n\t      Oper_Version: %d", *tptr);
-           printf("\n\t      Max_Version: %d", *(tptr+1));
-           printf("\n\t      Info block(0x%02X): ", *(tptr+2));
+           ND_PRINT((ndo, "\n\t    Feature - Priority Group (type 0x%x, length %d)",
+               LLDP_DCBX_PRIORITY_GROUPS_TLV, tlv_len));
+           ND_PRINT((ndo, "\n\t      Oper_Version: %d", *tptr));
+           ND_PRINT((ndo, "\n\t      Max_Version: %d", *(tptr + 1)));
+           ND_PRINT((ndo, "\n\t      Info block(0x%02X): ", *(tptr + 2)));

            tval = *(tptr+2);
            tval = *(tptr+2);

-           printf("Enable bit: %d, Willing bit: %d, Error Bit: %d",
+           ND_PRINT((ndo, "Enable bit: %d, Willing bit: %d, Error Bit: %d",

                (tval &  0x80) ? 1 : 0, (tval &  0x40) ? 1 : 0,
                (tval &  0x80) ? 1 : 0, (tval &  0x40) ? 1 : 0,

-               (tval &  0x20) ? 1 : 0);
-           printf("\n\t      SubType: %d", *(tptr+3));
-           printf("\n\t      Priority Allocation");
+               (tval &  0x20) ? 1 : 0));
+           ND_PRINT((ndo, "\n\t      SubType: %d", *(tptr + 3)));
+           ND_PRINT((ndo, "\n\t      Priority Allocation"));

 
            pgval = EXTRACT_32BITS(tptr+4);
            for (i = 0; i <= 7; i++) {
                tval = *(tptr+4+(i/2));
 
            pgval = EXTRACT_32BITS(tptr+4);
            for (i = 0; i <= 7; i++) {
                tval = *(tptr+4+(i/2));

-               printf("\n\t          PgId_%d: %d",
-                       i, (pgval >> (28-4*i)) & 0xF);
+               ND_PRINT((ndo, "\n\t          PgId_%d: %d",
+                       i, (pgval >> (28 - 4 * i)) & 0xF));

            }
            }

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

            for (i = 0; i <= 7; i++)
            for (i = 0; i <= 7; i++)

-               printf("\n\t          Pg percentage[%d]: %d", i, *(tptr+8+i));
-           printf("\n\t      NumTCsSupported: %d", *(tptr+8+8));
+               ND_PRINT((ndo, "\n\t          Pg percentage[%d]: %d", i, *(tptr + 8 + i)));
+           ND_PRINT((ndo, "\n\t      NumTCsSupported: %d", *(tptr + 8 + 8)));

            break;
         case LLDP_DCBX_PRIORITY_FLOW_CONTROL_TLV:
             if (tlv_len < 6) {
                 goto trunc;
             }
            break;
         case LLDP_DCBX_PRIORITY_FLOW_CONTROL_TLV:
             if (tlv_len < 6) {
                 goto trunc;
             }

-           printf("\n\t    Feature - Priority Flow Control");
-           printf(" (type 0x%x, length %d)",
-               LLDP_DCBX_PRIORITY_FLOW_CONTROL_TLV, tlv_len);
-           printf("\n\t      Oper_Version: %d", *tptr);
-           printf("\n\t      Max_Version: %d", *(tptr+1));
-           printf("\n\t      Info block(0x%02X): ", *(tptr+2));
+           ND_PRINT((ndo, "\n\t    Feature - Priority Flow Control"));
+           ND_PRINT((ndo, " (type 0x%x, length %d)",
+               LLDP_DCBX_PRIORITY_FLOW_CONTROL_TLV, tlv_len));
+           ND_PRINT((ndo, "\n\t      Oper_Version: %d", *tptr));
+           ND_PRINT((ndo, "\n\t      Max_Version: %d", *(tptr + 1)));
+           ND_PRINT((ndo, "\n\t      Info block(0x%02X): ", *(tptr + 2)));

            tval = *(tptr+2);
            tval = *(tptr+2);

-           printf("Enable bit: %d, Willing bit: %d, Error Bit: %d",
+           ND_PRINT((ndo, "Enable bit: %d, Willing bit: %d, Error Bit: %d",

                (tval &  0x80) ? 1 : 0, (tval &  0x40) ? 1 : 0,
                (tval &  0x80) ? 1 : 0, (tval &  0x40) ? 1 : 0,

-               (tval &  0x20) ? 1 : 0);
-           printf("\n\t      SubType: %d", *(tptr+3));
+               (tval &  0x20) ? 1 : 0));
+           ND_PRINT((ndo, "\n\t      SubType: %d", *(tptr + 3)));

            tval = *(tptr+4);
            tval = *(tptr+4);

-           printf("\n\t      PFC Config (0x%02X)", *(tptr+4));
+           ND_PRINT((ndo, "\n\t      PFC Config (0x%02X)", *(tptr + 4)));

            for (i = 0; i <= 7; i++)
            for (i = 0; i <= 7; i++)

-               printf("\n\t          Priority Bit %d: %s",
-                   i, (tval & (1 << i)) ? "Enabled" : "Disabled");
-           printf("\n\t      NumTCPFCSupported: %d", *(tptr+5));
+               ND_PRINT((ndo, "\n\t          Priority Bit %d: %s",
+                   i, (tval & (1 << i)) ? "Enabled" : "Disabled"));
+           ND_PRINT((ndo, "\n\t      NumTCPFCSupported: %d", *(tptr + 5)));

            break;
         case LLDP_DCBX_APPLICATION_TLV:
             if (tlv_len < 4) {
                 goto trunc;
             }
            break;
         case LLDP_DCBX_APPLICATION_TLV:
             if (tlv_len < 4) {
                 goto trunc;
             }

-           printf("\n\t    Feature - Application (type 0x%x, length %d)",
-               LLDP_DCBX_APPLICATION_TLV, tlv_len);
-           printf("\n\t      Oper_Version: %d", *tptr);
-           printf("\n\t      Max_Version: %d", *(tptr+1));
-           printf("\n\t      Info block(0x%02X): ", *(tptr+2));
+           ND_PRINT((ndo, "\n\t    Feature - Application (type 0x%x, length %d)",
+               LLDP_DCBX_APPLICATION_TLV, tlv_len));
+           ND_PRINT((ndo, "\n\t      Oper_Version: %d", *tptr));
+           ND_PRINT((ndo, "\n\t      Max_Version: %d", *(tptr + 1)));
+           ND_PRINT((ndo, "\n\t      Info block(0x%02X): ", *(tptr + 2)));

            tval = *(tptr+2);
            tval = *(tptr+2);

-           printf("Enable bit: %d, Willing bit: %d, Error Bit: %d",
+           ND_PRINT((ndo, "Enable bit: %d, Willing bit: %d, Error Bit: %d",

                (tval &  0x80) ? 1 : 0, (tval &  0x40) ? 1 : 0,
                (tval &  0x80) ? 1 : 0, (tval &  0x40) ? 1 : 0,

-               (tval &  0x20) ? 1 : 0);
-           printf("\n\t      SubType: %d", *(tptr+3));
+               (tval &  0x20) ? 1 : 0));
+           ND_PRINT((ndo, "\n\t      SubType: %d", *(tptr + 3)));

            tval = tlv_len - 4;
            mptr = tptr + 4;
            while (tval >= 6) {
            tval = tlv_len - 4;
            mptr = tptr + 4;
            while (tval >= 6) {

-               printf("\n\t      Application Value");
-               printf("\n\t          Application Protocol ID: 0x%04x",
-                       EXTRACT_16BITS(mptr));
+               ND_PRINT((ndo, "\n\t      Application Value"));
+               ND_PRINT((ndo, "\n\t          Application Protocol ID: 0x%04x",
+                       EXTRACT_16BITS(mptr)));

                uval = EXTRACT_24BITS(mptr+2);
                uval = EXTRACT_24BITS(mptr+2);

-               printf("\n\t          SF (0x%x) Application Protocol ID is %s",
+               ND_PRINT((ndo, "\n\t          SF (0x%x) Application Protocol ID is %s",

                        (uval >> 22),
                        (uval >> 22),

-                       (uval >> 22) ? "Socket Number" : "L2 EtherType");
-               printf("\n\t          OUI: 0x%06x", uval & 0x3fffff);
-               printf("\n\t          User Priority Map: 0x%02x", *(mptr+5));
+                       (uval >> 22) ? "Socket Number" : "L2 EtherType"));
+               ND_PRINT((ndo, "\n\t          OUI: 0x%06x", uval & 0x3fffff));
+               ND_PRINT((ndo, "\n\t          User Priority Map: 0x%02x", *(mptr + 5)));

                tval = tval - 6;
                mptr = mptr + 6;
            }
                tval = tval - 6;
                mptr = mptr + 6;
            }


@@ -1241,8 +1249,8 @@ lldp_private_dcbx_print(const u_char *pptr, u_int len)
        }
 
         /* do we also want to see a hex dump ? */
        }
 
         /* do we also want to see a hex dump ? */

-        if (vflag > 1 || (vflag && hexdump)) {
-           print_unknown_data(gndo,tptr,"\n\t    ", tlv_len);
+        if (ndo->ndo_vflag > 1 || (ndo->ndo_vflag && hexdump)) {
+           print_unknown_data(ndo, tptr, "\n\t    ", tlv_len);

         }
 
         tlen -= tlv_len;
         }
 
         tlen -= tlv_len;


@@ -1299,7 +1307,8 @@ lldp_network_addr_print(const u_char *tptr, u_int len) {
 }
 
 static int
 }
 
 static int

-lldp_mgmt_addr_tlv_print(const u_char *pptr, u_int len) {
+lldp_mgmt_addr_tlv_print(netdissect_options *ndo,
+                         const u_char *pptr, u_int len) {

 
     u_int8_t mgmt_addr_len, intf_num_subtype, oid_len;
     const u_char *tptr;
 
     u_int8_t mgmt_addr_len, intf_num_subtype, oid_len;
     const u_char *tptr;


@@ -1323,8 +1332,8 @@ lldp_mgmt_addr_tlv_print(const u_char *pptr, u_int len) {
     if (mgmt_addr == NULL) {
         return 0;
     }
     if (mgmt_addr == NULL) {
         return 0;
     }

-    printf("\n\t  Management Address length %u, %s",
-           mgmt_addr_len, mgmt_addr);
+    ND_PRINT((ndo, "\n\t  Management Address length %u, %s",
+           mgmt_addr_len, mgmt_addr));

     tptr += mgmt_addr_len;
     tlen -= mgmt_addr_len;
 
     tptr += mgmt_addr_len;
     tlen -= mgmt_addr_len;
 


@@ -1333,10 +1342,10 @@ lldp_mgmt_addr_tlv_print(const u_char *pptr, u_int len) {
     }
 
     intf_num_subtype = *tptr;
     }
 
     intf_num_subtype = *tptr;

-    printf("\n\t  %s Interface Numbering (%u): %u",
+    ND_PRINT((ndo, "\n\t  %s Interface Numbering (%u): %u",

            tok2str(lldp_intf_numb_subtype_values, "Unknown", intf_num_subtype),
            intf_num_subtype,
            tok2str(lldp_intf_numb_subtype_values, "Unknown", intf_num_subtype),
            intf_num_subtype,

-           EXTRACT_32BITS(tptr+1));
+           EXTRACT_32BITS(tptr + 1)));

 
     tptr += LLDP_INTF_NUM_LEN;
     tlen -= LLDP_INTF_NUM_LEN;
 
     tptr += LLDP_INTF_NUM_LEN;
     tlen -= LLDP_INTF_NUM_LEN;


@@ -1351,8 +1360,8 @@ lldp_mgmt_addr_tlv_print(const u_char *pptr, u_int len) {
             return 0;
         }
         if (oid_len) {
             return 0;
         }
         if (oid_len) {

-            printf("\n\t  OID length %u", oid_len);
-            safeputs(gndo, tptr + 1, oid_len);
+            ND_PRINT((ndo, "\n\t  OID length %u", oid_len));
+            safeputs(ndo, tptr + 1, oid_len);

         }
     }
 
         }
     }
 


@@ -1360,7 +1369,8 @@ lldp_mgmt_addr_tlv_print(const u_char *pptr, u_int len) {
 }
 
 void
 }
 
 void

-lldp_print(register const u_char *pptr, register u_int len) {
+lldp_print(netdissect_options *ndo,
+           register const u_char *pptr, register u_int len) {

 
     u_int8_t subtype;
     u_int16_t tlv, cap, ena_cap;
 
     u_int8_t subtype;
     u_int16_t tlv, cap, ena_cap;


@@ -1371,11 +1381,11 @@ lldp_print(register const u_char *pptr, register u_int len) {
     tptr = pptr;
     tlen = len;
 
     tptr = pptr;
     tlen = len;
 

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

 
     while (tlen >= sizeof(tlv)) {
 
 
     while (tlen >= sizeof(tlv)) {
 

-        TCHECK2(*tptr, sizeof(tlv));
+        ND_TCHECK2(*tptr, sizeof(tlv));

 
         tlv = EXTRACT_16BITS(tptr);
 
 
         tlv = EXTRACT_16BITS(tptr);
 


@@ -1386,10 +1396,10 @@ lldp_print(register const u_char *pptr, register u_int len) {
         tlen -= sizeof(tlv);
         tptr += sizeof(tlv);
 
         tlen -= sizeof(tlv);
         tptr += sizeof(tlv);
 

-        if (vflag) {
-            printf("\n\t%s TLV (%u), length %u",
+        if (ndo->ndo_vflag) {
+            ND_PRINT((ndo, "\n\t%s TLV (%u), length %u",

                    tok2str(lldp_tlv_values, "Unknown", tlv_type),
                    tok2str(lldp_tlv_values, "Unknown", tlv_type),

-                   tlv_type, tlv_len);
+                   tlv_type, tlv_len));

         }
 
         /* infinite loop check */
         }
 
         /* infinite loop check */


@@ -1397,7 +1407,7 @@ lldp_print(register const u_char *pptr, register u_int len) {
             break;
         }
 
             break;
         }
 

-        TCHECK2(*tptr, tlv_len);
+        ND_TCHECK2(*tptr, tlv_len);

         if (tlen < tlv_len) {
             goto trunc;
         }
         if (tlen < tlv_len) {
             goto trunc;
         }


@@ -1405,21 +1415,21 @@ lldp_print(register const u_char *pptr, register u_int len) {
         switch (tlv_type) {
 
         case LLDP_CHASSIS_ID_TLV:
         switch (tlv_type) {
 
         case LLDP_CHASSIS_ID_TLV:

-            if (vflag) {
+            if (ndo->ndo_vflag) {

                 if (tlv_len < 2) {
                     goto trunc;
                 }
                 subtype = *tptr;
                 if (tlv_len < 2) {
                     goto trunc;
                 }
                 subtype = *tptr;

-                printf("\n\t  Subtype %s (%u): ",
+                ND_PRINT((ndo, "\n\t  Subtype %s (%u): ",

                        tok2str(lldp_chassis_subtype_values, "Unknown", subtype),
                        tok2str(lldp_chassis_subtype_values, "Unknown", subtype),

-                       subtype);
+                       subtype));

 
                 switch (subtype) {
                 case LLDP_CHASSIS_MAC_ADDR_SUBTYPE:
                     if (tlv_len < 1+6) {
                         goto trunc;
                     }
 
                 switch (subtype) {
                 case LLDP_CHASSIS_MAC_ADDR_SUBTYPE:
                     if (tlv_len < 1+6) {
                         goto trunc;
                     }

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

                     break;
 
                 case LLDP_CHASSIS_INTF_NAME_SUBTYPE: /* fall through */
                     break;
 
                 case LLDP_CHASSIS_INTF_NAME_SUBTYPE: /* fall through */


@@ -1427,7 +1437,7 @@ lldp_print(register const u_char *pptr, register u_int len) {
                 case LLDP_CHASSIS_CHASSIS_COMP_SUBTYPE:
                 case LLDP_CHASSIS_INTF_ALIAS_SUBTYPE:
                 case LLDP_CHASSIS_PORT_COMP_SUBTYPE:
                 case LLDP_CHASSIS_CHASSIS_COMP_SUBTYPE:
                 case LLDP_CHASSIS_INTF_ALIAS_SUBTYPE:
                 case LLDP_CHASSIS_PORT_COMP_SUBTYPE:

-                    safeputs(gndo, tptr + 1, tlv_len - 1);
+                    safeputs(ndo, tptr + 1, tlv_len - 1);

                     break;
 
                 case LLDP_CHASSIS_NETWORK_ADDR_SUBTYPE:
                     break;
 
                 case LLDP_CHASSIS_NETWORK_ADDR_SUBTYPE:


@@ -1435,7 +1445,7 @@ lldp_print(register const u_char *pptr, register u_int len) {
                     if (network_addr == NULL) {
                         goto trunc;
                     }
                     if (network_addr == NULL) {
                         goto trunc;
                     }

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

                     break;
 
                 default:
                     break;
 
                 default:


@@ -1446,21 +1456,21 @@ lldp_print(register const u_char *pptr, register u_int len) {
             break;
 
         case LLDP_PORT_ID_TLV:
             break;
 
         case LLDP_PORT_ID_TLV:

-            if (vflag) {
+            if (ndo->ndo_vflag) {

                 if (tlv_len < 2) {
                     goto trunc;
                 }
                 subtype = *tptr;
                 if (tlv_len < 2) {
                     goto trunc;
                 }
                 subtype = *tptr;

-                printf("\n\t  Subtype %s (%u): ",
+                ND_PRINT((ndo, "\n\t  Subtype %s (%u): ",

                        tok2str(lldp_port_subtype_values, "Unknown", subtype),
                        tok2str(lldp_port_subtype_values, "Unknown", subtype),

-                       subtype);
+                       subtype));

 
                 switch (subtype) {
                 case LLDP_PORT_MAC_ADDR_SUBTYPE:
                     if (tlv_len < 1+6) {
                         goto trunc;
                     }
 
                 switch (subtype) {
                 case LLDP_PORT_MAC_ADDR_SUBTYPE:
                     if (tlv_len < 1+6) {
                         goto trunc;
                     }

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

                     break;
 
                 case LLDP_PORT_INTF_NAME_SUBTYPE: /* fall through */
                     break;
 
                 case LLDP_PORT_INTF_NAME_SUBTYPE: /* fall through */


@@ -1468,7 +1478,7 @@ lldp_print(register const u_char *pptr, register u_int len) {
                 case LLDP_PORT_AGENT_CIRC_ID_SUBTYPE:
                 case LLDP_PORT_INTF_ALIAS_SUBTYPE:
                 case LLDP_PORT_PORT_COMP_SUBTYPE:
                 case LLDP_PORT_AGENT_CIRC_ID_SUBTYPE:
                 case LLDP_PORT_INTF_ALIAS_SUBTYPE:
                 case LLDP_PORT_PORT_COMP_SUBTYPE:

-                    safeputs(gndo, tptr + 1, tlv_len - 1);
+                    safeputs(ndo, tptr + 1, tlv_len - 1);

                     break;
 
                 case LLDP_PORT_NETWORK_ADDR_SUBTYPE:
                     break;
 
                 case LLDP_PORT_NETWORK_ADDR_SUBTYPE:


@@ -1476,7 +1486,7 @@ lldp_print(register const u_char *pptr, register u_int len) {
                     if (network_addr == NULL) {
                         goto trunc;
                     }
                     if (network_addr == NULL) {
                         goto trunc;
                     }

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

                     break;
 
                 default:
                     break;
 
                 default:


@@ -1487,18 +1497,18 @@ lldp_print(register const u_char *pptr, register u_int len) {
             break;
 
         case LLDP_TTL_TLV:
             break;
 
         case LLDP_TTL_TLV:

-            if (vflag) {
+            if (ndo->ndo_vflag) {

                 if (tlv_len < 2) {
                     goto trunc;
                 }
                 if (tlv_len < 2) {
                     goto trunc;
                 }

-                printf(": TTL %us", EXTRACT_16BITS(tptr));
+                ND_PRINT((ndo, ": TTL %us", EXTRACT_16BITS(tptr)));

             }
             break;
 
         case LLDP_PORT_DESCR_TLV:
             }
             break;
 
         case LLDP_PORT_DESCR_TLV:

-            if (vflag) {
-                printf(": ");
-                safeputs(gndo, tptr, tlv_len);
+            if (ndo->ndo_vflag) {
+                ND_PRINT((ndo, ": "));
+                safeputs(ndo, tptr, tlv_len);

             }
             break;
 
             }
             break;
 


@@ -1507,19 +1517,19 @@ lldp_print(register const u_char *pptr, register u_int len) {
              * The system name is also print in non-verbose mode
              * similar to the CDP printer.
              */
              * The system name is also print in non-verbose mode
              * similar to the CDP printer.
              */

-            printf(": ");
-            safeputs(gndo, tptr, tlv_len);
+            ND_PRINT((ndo, ": "));
+            safeputs(ndo, tptr, tlv_len);

             break;
 
         case LLDP_SYSTEM_DESCR_TLV:
             break;
 
         case LLDP_SYSTEM_DESCR_TLV:

-            if (vflag) {
-                printf("\n\t  ");
-                safeputs(gndo, tptr, tlv_len);
+            if (ndo->ndo_vflag) {
+                ND_PRINT((ndo, "\n\t  "));
+                safeputs(ndo, tptr, tlv_len);

             }
             break;
 
         case LLDP_SYSTEM_CAP_TLV:
             }
             break;
 
         case LLDP_SYSTEM_CAP_TLV:

-            if (vflag) {
+            if (ndo->ndo_vflag) {

                 /*
                  * XXX - IEEE Std 802.1AB-2009 says the first octet
                  * if a chassis ID subtype, with the system
                 /*
                  * XXX - IEEE Std 802.1AB-2009 says the first octet
                  * if a chassis ID subtype, with the system


@@ -1531,41 +1541,41 @@ lldp_print(register const u_char *pptr, register u_int len) {
                 }
                 cap = EXTRACT_16BITS(tptr);
                 ena_cap = EXTRACT_16BITS(tptr+2);
                 }
                 cap = EXTRACT_16BITS(tptr);
                 ena_cap = EXTRACT_16BITS(tptr+2);

-                printf("\n\t  System  Capabilities [%s] (0x%04x)",
-                       bittok2str(lldp_cap_values, "none", cap), cap);
-                printf("\n\t  Enabled Capabilities [%s] (0x%04x)",
-                       bittok2str(lldp_cap_values, "none", ena_cap), ena_cap);
+                ND_PRINT((ndo, "\n\t  System  Capabilities [%s] (0x%04x)",
+                       bittok2str(lldp_cap_values, "none", cap), cap));
+                ND_PRINT((ndo, "\n\t  Enabled Capabilities [%s] (0x%04x)",
+                       bittok2str(lldp_cap_values, "none", ena_cap), ena_cap));

             }
             break;
 
         case LLDP_MGMT_ADDR_TLV:
             }
             break;
 
         case LLDP_MGMT_ADDR_TLV:

-            if (vflag) {
-                if (!lldp_mgmt_addr_tlv_print(tptr, tlv_len)) {
+            if (ndo->ndo_vflag) {
+                if (!lldp_mgmt_addr_tlv_print(ndo, tptr, tlv_len)) {

                     goto trunc;
                 }
             }
             break;
 
         case LLDP_PRIVATE_TLV:
                     goto trunc;
                 }
             }
             break;
 
         case LLDP_PRIVATE_TLV:

-            if (vflag) {
+            if (ndo->ndo_vflag) {

                 if (tlv_len < 3) {
                     goto trunc;
                 }
                 oui = EXTRACT_24BITS(tptr);
                 if (tlv_len < 3) {
                     goto trunc;
                 }
                 oui = EXTRACT_24BITS(tptr);

-                printf(": OUI %s (0x%06x)", tok2str(oui_values, "Unknown", oui), oui);
+                ND_PRINT((ndo, ": OUI %s (0x%06x)", tok2str(oui_values, "Unknown", oui), oui));

 
                 switch (oui) {
                 case OUI_IEEE_8021_PRIVATE:
 
                 switch (oui) {
                 case OUI_IEEE_8021_PRIVATE:

-                    hexdump = lldp_private_8021_print(tptr, tlv_len);
+                    hexdump = lldp_private_8021_print(ndo, tptr, tlv_len);

                     break;
                 case OUI_IEEE_8023_PRIVATE:
                     break;
                 case OUI_IEEE_8023_PRIVATE:

-                    hexdump = lldp_private_8023_print(tptr, tlv_len);
+                    hexdump = lldp_private_8023_print(ndo, tptr, tlv_len);

                     break;
                 case OUI_TIA:
                     break;
                 case OUI_TIA:

-                    hexdump = lldp_private_tia_print(tptr, tlv_len);
+                    hexdump = lldp_private_tia_print(ndo, tptr, tlv_len);

                     break;
                 case OUI_DCBX:
                     break;
                 case OUI_DCBX:

-                    hexdump = lldp_private_dcbx_print(tptr, tlv_len);
+                    hexdump = lldp_private_dcbx_print(ndo, tptr, tlv_len);

                     break;
                 default:
                     hexdump = TRUE;
                     break;
                 default:
                     hexdump = TRUE;


@@ -1580,8 +1590,8 @@ lldp_print(register const u_char *pptr, register u_int len) {
         }
 
         /* do we also want to see a hex dump ? */
         }
 
         /* do we also want to see a hex dump ? */

-        if (vflag > 1 || (vflag && hexdump)) {
-            print_unknown_data(gndo,tptr,"\n\t  ", tlv_len);
+        if (ndo->ndo_vflag > 1 || (ndo->ndo_vflag && hexdump)) {
+            print_unknown_data(ndo, tptr, "\n\t  ", tlv_len);

         }
 
         tlen -= tlv_len;
         }
 
         tlen -= tlv_len;


@@ -1589,7 +1599,7 @@ lldp_print(register const u_char *pptr, register u_int len) {
     }
     return;
  trunc:
     }
     return;
  trunc:

-    printf("\n\t[|LLDP]");
+    ND_PRINT((ndo, "\n\t[|LLDP]"));

 }
 
 /*
 }
 
 /*

diff --git a/print-ppp.c b/print-ppp.c
index 4c07bb63d00384341aaa31126484100d44bbab71..e42a5398bc1bfee182d58f870e54de4e9844072a 100644 (file)
--- a/print-ppp.c
+++ b/print-ppp.c
@@ -29,6 +29,7 @@
  * o BAP support
  */
 
  * o BAP support
  */
 

+#define NETDISSECT_REWORKED

 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif


@@ -40,7 +41,6 @@
 #include <net/if_ppp.h>
 #endif
 
 #include <net/if_ppp.h>
 #endif
 

-#include <stdio.h>

 #include <stdlib.h>
 
 #include "interface.h"
 #include <stdlib.h>
 
 #include "interface.h"


@@ -401,73 +401,68 @@ static const struct tok papcode_values[] = {
 #define BAP_CSIND      7
 #define BAP_CSRES      8
 
 #define BAP_CSIND      7
 #define BAP_CSRES      8
 

-static void handle_ctrl_proto (u_int proto,const u_char *p, int length);
-static void handle_chap (const u_char *p, int length);
-static void handle_pap (const u_char *p, int length);
-static void handle_bap (const u_char *p, int length);
-static void handle_mlppp(const u_char *p, int length);
-static int print_lcp_config_options (const u_char *p, int);
-static int print_ipcp_config_options (const u_char *p, int);
-static int print_ip6cp_config_options (const u_char *p, int);
-static int print_ccp_config_options (const u_char *p, int);
-static int print_bacp_config_options (const u_char *p, int);
-static void handle_ppp (u_int proto, const u_char *p, int length);
-static void ppp_hdlc(const u_char *p, int length);
+static int print_lcp_config_options(netdissect_options *, const u_char *p, int);
+static int print_ipcp_config_options(netdissect_options *, const u_char *p, int);
+static int print_ip6cp_config_options(netdissect_options *, const u_char *p, int);
+static int print_ccp_config_options(netdissect_options *, const u_char *p, int);
+static int print_bacp_config_options(netdissect_options *, const u_char *p, int);
+static void handle_ppp(netdissect_options *, u_int proto, const u_char *p, int length);

 
 /* generic Control Protocol (e.g. LCP, IPCP, CCP, etc.) handler */
 static void
 
 /* generic Control Protocol (e.g. LCP, IPCP, CCP, etc.) handler */
 static void

-handle_ctrl_proto(u_int proto, const u_char *pptr, int length)
+handle_ctrl_proto(netdissect_options *ndo,
+                  u_int proto, const u_char *pptr, int length)

 {
        const char *typestr;
        u_int code, len;
 {
        const char *typestr;
        u_int code, len;

-       int (*pfunc)(const u_char *, int);
+       int (*pfunc)(netdissect_options *, const u_char *, int);

        int x, j;
         const u_char *tptr;
 
         tptr=pptr;
 
         typestr = tok2str(ppptype2str, "unknown ctrl-proto (0x%04x)", proto);
        int x, j;
         const u_char *tptr;
 
         tptr=pptr;
 
         typestr = tok2str(ppptype2str, "unknown ctrl-proto (0x%04x)", proto);

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

 
        if (length < 4) /* FIXME weak boundary checking */
                goto trunc;
 
        if (length < 4) /* FIXME weak boundary checking */
                goto trunc;

-       TCHECK2(*tptr, 2);
+       ND_TCHECK2(*tptr, 2);

 
        code = *tptr++;
 
 
        code = *tptr++;
 

-        printf("%s (0x%02x), id %u, length %u",
-               tok2str(cpcodes, "Unknown Opcode",code),
-               code,
-               *tptr++, /* ID */
-               length+2);
+       ND_PRINT((ndo, "%s (0x%02x), id %u, length %u",
+                 tok2str(cpcodes, "Unknown Opcode",code),
+                 code,
+                 *tptr++, /* ID */
+                 length + 2));

 
 

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

 
        if (length <= 4)
                return;    /* there may be a NULL confreq etc. */
 
 
        if (length <= 4)
                return;    /* there may be a NULL confreq etc. */
 

-       TCHECK2(*tptr, 2);
+       ND_TCHECK2(*tptr, 2);

        len = EXTRACT_16BITS(tptr);
        tptr += 2;
 
        len = EXTRACT_16BITS(tptr);
        tptr += 2;
 

-        printf("\n\tencoded length %u (=Option(s) length %u)",len,len-4);
+       ND_PRINT((ndo, "\n\tencoded length %u (=Option(s) length %u)", len, len - 4));

 
 

-        if (vflag>1)
-            print_unknown_data(gndo,pptr-2,"\n\t",6);
+       if (ndo->ndo_vflag > 1)
+               print_unknown_data(ndo, pptr - 2, "\n\t", 6);

 
 
        switch (code) {
        case CPCODES_VEXT:
                if (length < 11)
                        break;
 
 
        switch (code) {
        case CPCODES_VEXT:
                if (length < 11)
                        break;

-               TCHECK2(*tptr, 4);
-               printf("\n\t  Magic-Num 0x%08x", EXTRACT_32BITS(tptr));
+               ND_TCHECK2(*tptr, 4);
+               ND_PRINT((ndo, "\n\t  Magic-Num 0x%08x", EXTRACT_32BITS(tptr)));

                tptr += 4;
                tptr += 4;

-               TCHECK2(*tptr, 3);
-               printf(" Vendor: %s (%u)",
+               ND_TCHECK2(*tptr, 3);
+               ND_PRINT((ndo, " Vendor: %s (%u)",

                        tok2str(oui_values,"Unknown",EXTRACT_24BITS(tptr)),
                        tok2str(oui_values,"Unknown",EXTRACT_24BITS(tptr)),

-                       EXTRACT_24BITS(tptr));
+                       EXTRACT_24BITS(tptr)));

                /* XXX: need to decode Kind and Value(s)? */
                break;
        case CPCODES_CONF_REQ:
                /* XXX: need to decode Kind and Value(s)? */
                break;
        case CPCODES_CONF_REQ:


@@ -504,7 +499,7 @@ handle_ctrl_proto(u_int proto, const u_char *pptr, int length)
                        if (pfunc == NULL) /* catch the above null pointer if unknown CP */
                                break;
 
                        if (pfunc == NULL) /* catch the above null pointer if unknown CP */
                                break;
 

-                       if ((j = (*pfunc)(tptr, len)) == 0)
+                       if ((j = (*pfunc)(ndo, tptr, len)) == 0)

                                break;
                        x -= j;
                        tptr += j;
                                break;
                        x -= j;
                        tptr += j;


@@ -521,139 +516,141 @@ handle_ctrl_proto(u_int proto, const u_char *pptr, int length)
        case CPCODES_PROT_REJ:
                if (length < 6)
                        break;
        case CPCODES_PROT_REJ:
                if (length < 6)
                        break;

-               TCHECK2(*tptr, 2);
-               printf("\n\t  Rejected %s Protocol (0x%04x)",
+               ND_TCHECK2(*tptr, 2);
+               ND_PRINT((ndo, "\n\t  Rejected %s Protocol (0x%04x)",

                       tok2str(ppptype2str,"unknown", EXTRACT_16BITS(tptr)),
                       tok2str(ppptype2str,"unknown", EXTRACT_16BITS(tptr)),

-                      EXTRACT_16BITS(tptr));
+                      EXTRACT_16BITS(tptr)));

                /* XXX: need to decode Rejected-Information? - hexdump for now */
                /* XXX: need to decode Rejected-Information? - hexdump for now */

-                if (len > 6) {
-                        printf("\n\t  Rejected Packet");
-                        print_unknown_data(gndo,tptr+2,"\n\t    ",len-2);
-                }
+               if (len > 6) {
+                       ND_PRINT((ndo, "\n\t  Rejected Packet"));
+                       print_unknown_data(ndo, tptr + 2, "\n\t    ", len - 2);
+               }

                break;
        case CPCODES_ECHO_REQ:
        case CPCODES_ECHO_RPL:
        case CPCODES_DISC_REQ:
                if (length < 8)
                        break;
                break;
        case CPCODES_ECHO_REQ:
        case CPCODES_ECHO_RPL:
        case CPCODES_DISC_REQ:
                if (length < 8)
                        break;

-               TCHECK2(*tptr, 4);
-               printf("\n\t  Magic-Num 0x%08x", EXTRACT_32BITS(tptr));
+               ND_TCHECK2(*tptr, 4);
+               ND_PRINT((ndo, "\n\t  Magic-Num 0x%08x", EXTRACT_32BITS(tptr)));

                /* XXX: need to decode Data? - hexdump for now */
                /* XXX: need to decode Data? - hexdump for now */

-                if (len > 8) {
-                        printf("\n\t  -----trailing data-----");
-                        TCHECK2(tptr[4], len-8);
-                        print_unknown_data(gndo,tptr+4,"\n\t  ",len-8);
-                }
+               if (len > 8) {
+                       ND_PRINT((ndo, "\n\t  -----trailing data-----"));
+                       ND_TCHECK2(tptr[4], len - 8);
+                       print_unknown_data(ndo, tptr + 4, "\n\t  ", len - 8);
+               }

                break;
        case CPCODES_ID:
                if (length < 8)
                        break;
                break;
        case CPCODES_ID:
                if (length < 8)
                        break;

-               TCHECK2(*tptr, 4);
-               printf("\n\t  Magic-Num 0x%08x", EXTRACT_32BITS(tptr));
+               ND_TCHECK2(*tptr, 4);
+               ND_PRINT((ndo, "\n\t  Magic-Num 0x%08x", EXTRACT_32BITS(tptr)));

                /* RFC 1661 says this is intended to be human readable */
                /* RFC 1661 says this is intended to be human readable */

-                if (len > 8) {
-                        printf("\n\t  Message\n\t    ");
-                        fn_printn(tptr+4,len-4,snapend);
-                }
+               if (len > 8) {
+                       ND_PRINT((ndo, "\n\t  Message\n\t    "));
+                       fn_printn(tptr + 4, len - 4, ndo->ndo_snapend);
+               }

                break;
        case CPCODES_TIME_REM:
                if (length < 12)
                        break;
                break;
        case CPCODES_TIME_REM:
                if (length < 12)
                        break;

-               TCHECK2(*tptr, 4);
-               printf("\n\t  Magic-Num 0x%08x", EXTRACT_32BITS(tptr));
-               TCHECK2(*(tptr + 4), 4);
-               printf(", Seconds-Remaining %us", EXTRACT_32BITS(tptr + 4));
+               ND_TCHECK2(*tptr, 4);
+               ND_PRINT((ndo, "\n\t  Magic-Num 0x%08x", EXTRACT_32BITS(tptr)));
+               ND_TCHECK2(*(tptr + 4), 4);
+               ND_PRINT((ndo, ", Seconds-Remaining %us", EXTRACT_32BITS(tptr + 4)));

                /* XXX: need to decode Message? */
                break;
        default:
                /* XXX: need to decode Message? */
                break;
        default:

-            /* XXX this is dirty but we do not get the
-             * original pointer passed to the begin
-             * the PPP packet */
-                if (vflag <= 1)
-                    print_unknown_data(gndo,pptr-2,"\n\t  ",length+2);
+               /* XXX this is dirty but we do not get the
+                * original pointer passed to the begin
+                * the PPP packet */
+               if (ndo->ndo_vflag <= 1)
+                       print_unknown_data(ndo, pptr - 2, "\n\t  ", length + 2);

                break;
        }
        return;
 
 trunc:
                break;
        }
        return;
 
 trunc:

-       printf("[|%s]", typestr);
+       ND_PRINT((ndo, "[|%s]", typestr));

 }
 
 /* LCP config options */
 static int
 }
 
 /* LCP config options */
 static int

-print_lcp_config_options(const u_char *p, int length)
+print_lcp_config_options(netdissect_options *ndo,
+                         const u_char *p, int length)

 {
        int len, opt;
 
        if (length < 2)
                return 0;
 {
        int len, opt;
 
        if (length < 2)
                return 0;

-       TCHECK2(*p, 2);
+       ND_TCHECK2(*p, 2);

        len = p[1];
        opt = p[0];
        if (length < len)
                return 0;
        if (len < 2) {
                if ((opt >= LCPOPT_MIN) && (opt <= LCPOPT_MAX))
        len = p[1];
        opt = p[0];
        if (length < len)
                return 0;
        if (len < 2) {
                if ((opt >= LCPOPT_MIN) && (opt <= LCPOPT_MAX))

-                       printf("\n\t  %s Option (0x%02x), length %u (length bogus, should be >= 2)", lcpconfopts[opt],opt,len);
+                       ND_PRINT((ndo, "\n\t  %s Option (0x%02x), length %u (length bogus, should be >= 2)",
+                                 lcpconfopts[opt], opt, len));

                else
                else

-                       printf("\n\tunknown LCP option 0x%02x", opt);
+                       ND_PRINT((ndo, "\n\tunknown LCP option 0x%02x", opt));

                return 0;
        }
        if ((opt >= LCPOPT_MIN) && (opt <= LCPOPT_MAX))
                return 0;
        }
        if ((opt >= LCPOPT_MIN) && (opt <= LCPOPT_MAX))

-               printf("\n\t  %s Option (0x%02x), length %u", lcpconfopts[opt],opt,len);
+               ND_PRINT((ndo, "\n\t  %s Option (0x%02x), length %u", lcpconfopts[opt], opt, len));

        else {
        else {

-               printf("\n\tunknown LCP option 0x%02x", opt);
+               ND_PRINT((ndo, "\n\tunknown LCP option 0x%02x", opt));

                return len;
        }
 
        switch (opt) {
        case LCPOPT_VEXT:
                if (len < 6) {
                return len;
        }
 
        switch (opt) {
        case LCPOPT_VEXT:
                if (len < 6) {

-                       printf(" (length bogus, should be >= 6)");
+                       ND_PRINT((ndo, " (length bogus, should be >= 6)"));

                        return len;
                }
                        return len;
                }

-               TCHECK2(*(p + 2), 3);
-               printf(": Vendor: %s (%u)",
+               ND_TCHECK2(*(p + 2), 3);
+               ND_PRINT((ndo, ": Vendor: %s (%u)",

                        tok2str(oui_values,"Unknown",EXTRACT_24BITS(p+2)),
                        tok2str(oui_values,"Unknown",EXTRACT_24BITS(p+2)),

-                       EXTRACT_24BITS(p+2));
+                       EXTRACT_24BITS(p + 2)));

 #if 0
 #if 0

-               TCHECK(p[5]);
-               printf(", kind: 0x%02x", p[5]);
-               printf(", Value: 0x")
+               ND_TCHECK(p[5]);
+               ND_PRINT((ndo, ", kind: 0x%02x", p[5]));
+               ND_PRINT((ndo, ", Value: 0x"));

                for (i = 0; i < len - 6; i++) {
                for (i = 0; i < len - 6; i++) {

-                       TCHECK(p[6 + i]);
-                       printf("%02x", p[6 + i]);
+                       ND_TCHECK(p[6 + i]);
+                       ND_PRINT((ndo, "%02x", p[6 + i]));

                }
 #endif
                break;
        case LCPOPT_MRU:
                if (len != 4) {
                }
 #endif
                break;
        case LCPOPT_MRU:
                if (len != 4) {

-                       printf(" (length bogus, should be = 4)");
+                       ND_PRINT((ndo, " (length bogus, should be = 4)"));

                        return len;
                }
                        return len;
                }

-               TCHECK2(*(p + 2), 2);
-               printf(": %u", EXTRACT_16BITS(p + 2));
+               ND_TCHECK2(*(p + 2), 2);
+               ND_PRINT((ndo, ": %u", EXTRACT_16BITS(p + 2)));

                break;
        case LCPOPT_ACCM:
                if (len != 6) {
                break;
        case LCPOPT_ACCM:
                if (len != 6) {

-                       printf(" (length bogus, should be = 6)");
+                       ND_PRINT((ndo, " (length bogus, should be = 6)"));

                        return len;
                }
                        return len;
                }

-               TCHECK2(*(p + 2), 4);
-               printf(": 0x%08x", EXTRACT_32BITS(p + 2));
+               ND_TCHECK2(*(p + 2), 4);
+               ND_PRINT((ndo, ": 0x%08x", EXTRACT_32BITS(p + 2)));

                break;
        case LCPOPT_AP:
                if (len < 4) {
                break;
        case LCPOPT_AP:
                if (len < 4) {

-                       printf(" (length bogus, should be >= 4)");
+                       ND_PRINT((ndo, " (length bogus, should be >= 4)"));

                        return len;
                }
                        return len;
                }

-               TCHECK2(*(p + 2), 2);
-                printf(": %s", tok2str(ppptype2str,"Unknown Auth Proto (0x04x)",EXTRACT_16BITS(p+2)));
+               ND_TCHECK2(*(p + 2), 2);
+               ND_PRINT((ndo, ": %s", tok2str(ppptype2str, "Unknown Auth Proto (0x04x)", EXTRACT_16BITS(p + 2))));

 
                switch (EXTRACT_16BITS(p+2)) {
                case PPP_CHAP:
 
                switch (EXTRACT_16BITS(p+2)) {
                case PPP_CHAP:

-                       TCHECK(p[4]);
-                        printf(", %s",tok2str(authalg_values,"Unknown Auth Alg %u",p[4]));
+                       ND_TCHECK(p[4]);
+                       ND_PRINT((ndo, ", %s", tok2str(authalg_values, "Unknown Auth Alg %u", p[4])));

                        break;
                case PPP_PAP: /* fall through */
                case PPP_EAP:
                        break;
                case PPP_PAP: /* fall through */
                case PPP_EAP:


@@ -661,27 +658,27 @@ print_lcp_config_options(const u_char *p, int length)
                case PPP_SPAP_OLD:
                         break;
                default:
                case PPP_SPAP_OLD:
                         break;
                default:

-                        print_unknown_data(gndo,p,"\n\t",len);
+                       print_unknown_data(ndo, p, "\n\t", len);

                }
                break;
        case LCPOPT_QP:
                if (len < 4) {
                }
                break;
        case LCPOPT_QP:
                if (len < 4) {

-                       printf(" (length bogus, should be >= 4)");
+                       ND_PRINT((ndo, " (length bogus, should be >= 4)"));

                        return 0;
                }
                        return 0;
                }

-               TCHECK2(*(p + 2), 2);
+               ND_TCHECK2(*(p + 2), 2);

                if (EXTRACT_16BITS(p+2) == PPP_LQM)
                if (EXTRACT_16BITS(p+2) == PPP_LQM)

-                       printf(": LQR");
+                       ND_PRINT((ndo, ": LQR"));

                else
                else

-                       printf(": unknown");
+                       ND_PRINT((ndo, ": unknown"));

                break;
        case LCPOPT_MN:
                if (len != 6) {
                break;
        case LCPOPT_MN:
                if (len != 6) {

-                       printf(" (length bogus, should be = 6)");
+                       ND_PRINT((ndo, " (length bogus, should be = 6)"));

                        return 0;
                }
                        return 0;
                }

-               TCHECK2(*(p + 2), 4);
-               printf(": 0x%08x", EXTRACT_32BITS(p + 2));
+               ND_TCHECK2(*(p + 2), 4);
+               ND_PRINT((ndo, ": 0x%08x", EXTRACT_32BITS(p + 2)));

                break;
        case LCPOPT_PFC:
                break;
                break;
        case LCPOPT_PFC:
                break;


@@ -689,69 +686,69 @@ print_lcp_config_options(const u_char *p, int length)
                break;
        case LCPOPT_LD:
                if (len != 4) {
                break;
        case LCPOPT_LD:
                if (len != 4) {

-                       printf(" (length bogus, should be = 4)");
+                       ND_PRINT((ndo, " (length bogus, should be = 4)"));

                        return 0;
                }
                        return 0;
                }

-               TCHECK2(*(p + 2), 2);
-               printf(": 0x%04x", EXTRACT_16BITS(p + 2));
+               ND_TCHECK2(*(p + 2), 2);
+               ND_PRINT((ndo, ": 0x%04x", EXTRACT_16BITS(p + 2)));

                break;
        case LCPOPT_CBACK:
                if (len < 3) {
                break;
        case LCPOPT_CBACK:
                if (len < 3) {

-                       printf(" (length bogus, should be >= 3)");
+                       ND_PRINT((ndo, " (length bogus, should be >= 3)"));

                        return 0;
                }
                        return 0;
                }

-               printf(": ");
-               TCHECK(p[2]);
-               printf(": Callback Operation %s (%u)",
-                       tok2str(ppp_callback_values,"Unknown",p[2]),
-                       p[2]);
+               ND_PRINT((ndo, ": "));
+               ND_TCHECK(p[2]);
+               ND_PRINT((ndo, ": Callback Operation %s (%u)",
+                       tok2str(ppp_callback_values, "Unknown", p[2]),
+                       p[2]));

                break;
        case LCPOPT_MLMRRU:
                if (len != 4) {
                break;
        case LCPOPT_MLMRRU:
                if (len != 4) {

-                       printf(" (length bogus, should be = 4)");
+                       ND_PRINT((ndo, " (length bogus, should be = 4)"));

                        return 0;
                }
                        return 0;
                }

-               TCHECK2(*(p + 2), 2);
-               printf(": %u", EXTRACT_16BITS(p + 2));
+               ND_TCHECK2(*(p + 2), 2);
+               ND_PRINT((ndo, ": %u", EXTRACT_16BITS(p + 2)));

                break;
        case LCPOPT_MLED:
                if (len < 3) {
                break;
        case LCPOPT_MLED:
                if (len < 3) {

-                       printf(" (length bogus, should be >= 3)");
+                       ND_PRINT((ndo, " (length bogus, should be >= 3)"));

                        return 0;
                }
                        return 0;
                }

-               TCHECK(p[2]);
+               ND_TCHECK(p[2]);

                switch (p[2]) {         /* class */
                case MEDCLASS_NULL:
                switch (p[2]) {         /* class */
                case MEDCLASS_NULL:

-                       printf(": Null");
+                       ND_PRINT((ndo, ": Null"));

                        break;
                case MEDCLASS_LOCAL:
                        break;
                case MEDCLASS_LOCAL:

-                       printf(": Local"); /* XXX */
+                       ND_PRINT((ndo, ": Local")); /* XXX */

                        break;
                case MEDCLASS_IPV4:
                        if (len != 7) {
                        break;
                case MEDCLASS_IPV4:
                        if (len != 7) {

-                               printf(" (length bogus, should be = 7)");
+                               ND_PRINT((ndo, " (length bogus, should be = 7)"));

                                return 0;
                        }
                                return 0;
                        }

-                       TCHECK2(*(p + 3), 4);
-                       printf(": IPv4 %s", ipaddr_string(p + 3));
+                       ND_TCHECK2(*(p + 3), 4);
+                       ND_PRINT((ndo, ": IPv4 %s", ipaddr_string(p + 3)));

                        break;
                case MEDCLASS_MAC:
                        if (len != 9) {
                        break;
                case MEDCLASS_MAC:
                        if (len != 9) {

-                               printf(" (length bogus, should be = 9)");
+                               ND_PRINT((ndo, " (length bogus, should be = 9)"));

                                return 0;
                        }
                                return 0;
                        }

-                       TCHECK(p[8]);
-                       printf(": MAC %02x:%02x:%02x:%02x:%02x:%02x",
-                              p[3], p[4], p[5], p[6], p[7], p[8]);
+                       ND_TCHECK(p[8]);
+                       ND_PRINT((ndo, ": MAC %02x:%02x:%02x:%02x:%02x:%02x",
+                              p[3], p[4], p[5], p[6], p[7], p[8]));

                        break;
                case MEDCLASS_MNB:
                        break;
                case MEDCLASS_MNB:

-                       printf(": Magic-Num-Block"); /* XXX */
+                       ND_PRINT((ndo, ": Magic-Num-Block")); /* XXX */

                        break;
                case MEDCLASS_PSNDN:
                        break;
                case MEDCLASS_PSNDN:

-                       printf(": PSNDN"); /* XXX */
+                       ND_PRINT((ndo, ": PSNDN")); /* XXX */

                        break;
                default:
                        break;
                default:

-                       printf(": Unknown class %u", p[2]);
+                       ND_PRINT((ndo, ": Unknown class %u", p[2]));

                        break;
                }
                break;
                        break;
                }
                break;


@@ -779,23 +776,23 @@ print_lcp_config_options(const u_char *p, int length)
        case LCPOPT_PPPMUX:
                break;
 #endif
        case LCPOPT_PPPMUX:
                break;
 #endif

-        default:
-               /*
-                * Unknown option; dump it as raw bytes now if we're
-                * not going to do so below.
-                */
-                if(vflag<2)
-                        print_unknown_data(gndo,&p[2],"\n\t    ",len-2);
-                break;
+       default:
+               /*
+                * Unknown option; dump it as raw bytes now if we're
+                * not going to do so below.
+                */
+               if (ndo->ndo_vflag < 2)
+                       print_unknown_data(ndo, &p[2], "\n\t    ", len - 2);
+               break;

        }
 
        }
 

-        if (vflag>1)
-                print_unknown_data(gndo,&p[2],"\n\t    ",len-2); /* exclude TLV header */
+       if (ndo->ndo_vflag > 1)
+               print_unknown_data(ndo, &p[2], "\n\t    ", len - 2); /* exclude TLV header */

 
        return len;
 
 trunc:
 
        return len;
 
 trunc:

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

        return 0;
 }
 
        return 0;
 }
 


@@ -807,22 +804,22 @@ static const struct tok ppp_ml_flag_values[] = {
 };
 
 static void
 };
 
 static void

-handle_mlppp(const u_char *p, int length) {
+handle_mlppp(netdissect_options *ndo,
+             const u_char *p, int length) {

 
 

-    if (!eflag)
-        printf("MLPPP, ");
+    if (!ndo->ndo_eflag)
+        ND_PRINT((ndo, "MLPPP, "));

 
 

-    printf("seq 0x%03x, Flags [%s], length %u",
+    ND_PRINT((ndo, "seq 0x%03x, Flags [%s], length %u",

            (EXTRACT_16BITS(p))&0x0fff, /* only support 12-Bit sequence space for now */
            bittok2str(ppp_ml_flag_values, "none", *p & 0xc0),
            (EXTRACT_16BITS(p))&0x0fff, /* only support 12-Bit sequence space for now */
            bittok2str(ppp_ml_flag_values, "none", *p & 0xc0),

-           length);
-
-    return;
+           length));

 }
 
 /* CHAP */
 static void
 }
 
 /* CHAP */
 static void

-handle_chap(const u_char *p, int length)
+handle_chap(netdissect_options *ndo,
+            const u_char *p, int length)

 {
        u_int code, len;
        int val_size, name_size, msg_size;
 {
        u_int code, len;
        int val_size, name_size, msg_size;


@@ -831,26 +828,26 @@ handle_chap(const u_char *p, int length)
 
        p0 = p;
        if (length < 1) {
 
        p0 = p;
        if (length < 1) {

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

                return;
        } else if (length < 4) {
                return;
        } else if (length < 4) {

-               TCHECK(*p);
-               printf("[|chap 0x%02x]", *p);
+               ND_TCHECK(*p);
+               ND_PRINT((ndo, "[|chap 0x%02x]", *p));

                return;
        }
 
                return;
        }
 

-       TCHECK(*p);
+       ND_TCHECK(*p);

        code = *p;
        code = *p;

-        printf("CHAP, %s (0x%02x)",
+       ND_PRINT((ndo, "CHAP, %s (0x%02x)",

                tok2str(chapcode_values,"unknown",code),
                tok2str(chapcode_values,"unknown",code),

-               code);
+               code));

        p++;
 
        p++;
 

-       TCHECK(*p);
-       printf(", id %u", *p);          /* ID */
+       ND_TCHECK(*p);
+       ND_PRINT((ndo, ", id %u", *p));         /* ID */

        p++;
 
        p++;
 

-       TCHECK2(*p, 2);
+       ND_TCHECK2(*p, 2);

        len = EXTRACT_16BITS(p);
        p += 2;
 
        len = EXTRACT_16BITS(p);
        p += 2;
 


@@ -866,42 +863,43 @@ handle_chap(const u_char *p, int length)
        case CHAP_RESP:
                if (length - (p - p0) < 1)
                        return;
        case CHAP_RESP:
                if (length - (p - p0) < 1)
                        return;

-               TCHECK(*p);
+               ND_TCHECK(*p);

                val_size = *p;          /* value size */
                p++;
                if (length - (p - p0) < val_size)
                        return;
                val_size = *p;          /* value size */
                p++;
                if (length - (p - p0) < val_size)
                        return;

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

                for (i = 0; i < val_size; i++) {
                for (i = 0; i < val_size; i++) {

-                       TCHECK(*p);
-                       printf("%02x", *p++);
+                       ND_TCHECK(*p);
+                       ND_PRINT((ndo, "%02x", *p++));

                }
                name_size = len - (p - p0);
                }
                name_size = len - (p - p0);

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

                for (i = 0; i < name_size; i++) {
                for (i = 0; i < name_size; i++) {

-                       TCHECK(*p);
-                       safeputchar(gndo, *p++);
+                       ND_TCHECK(*p);
+                       safeputchar(ndo, *p++);

                }
                break;
        case CHAP_SUCC:
        case CHAP_FAIL:
                msg_size = len - (p - p0);
                }
                break;
        case CHAP_SUCC:
        case CHAP_FAIL:
                msg_size = len - (p - p0);

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

                for (i = 0; i< msg_size; i++) {
                for (i = 0; i< msg_size; i++) {

-                       TCHECK(*p);
-                       safeputchar(gndo, *p++);
+                       ND_TCHECK(*p);
+                       safeputchar(ndo, *p++);

                }
                break;
        }
        return;
 
 trunc:
                }
                break;
        }
        return;
 
 trunc:

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

 }
 
 /* PAP (see RFC 1334) */
 static void
 }
 
 /* PAP (see RFC 1334) */
 static void

-handle_pap(const u_char *p, int length)
+handle_pap(netdissect_options *ndo,
+           const u_char *p, int length)

 {
        u_int code, len;
        int peerid_len, passwd_len, msg_len;
 {
        u_int code, len;
        int peerid_len, passwd_len, msg_len;


@@ -910,36 +908,36 @@ handle_pap(const u_char *p, int length)
 
        p0 = p;
        if (length < 1) {
 
        p0 = p;
        if (length < 1) {

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

                return;
        } else if (length < 4) {
                return;
        } else if (length < 4) {

-               TCHECK(*p);
-               printf("[|pap 0x%02x]", *p);
+               ND_TCHECK(*p);
+               ND_PRINT((ndo, "[|pap 0x%02x]", *p));

                return;
        }
 
                return;
        }
 

-       TCHECK(*p);
+       ND_TCHECK(*p);

        code = *p;
        code = *p;

-        printf("PAP, %s (0x%02x)",
-               tok2str(papcode_values,"unknown",code),
-               code);
+       ND_PRINT((ndo, "PAP, %s (0x%02x)",
+                 tok2str(papcode_values, "unknown", code),
+                 code));

        p++;
 
        p++;
 

-       TCHECK(*p);
-       printf(", id %u", *p);          /* ID */
+       ND_TCHECK(*p);
+       ND_PRINT((ndo, ", id %u", *p));         /* ID */

        p++;
 
        p++;
 

-       TCHECK2(*p, 2);
+       ND_TCHECK2(*p, 2);

        len = EXTRACT_16BITS(p);
        p += 2;
 
        if ((int)len > length) {
        len = EXTRACT_16BITS(p);
        p += 2;
 
        if ((int)len > length) {

-               printf(", length %u > packet size", len);
+               ND_PRINT((ndo, ", length %u > packet size", len));

                return;
        }
        length = len;
        if (length < (p - p0)) {
                return;
        }
        length = len;
        if (length < (p - p0)) {

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

                return;
        }
 
                return;
        }
 


@@ -947,55 +945,56 @@ handle_pap(const u_char *p, int length)
        case PAP_AREQ:
                if (length - (p - p0) < 1)
                        return;
        case PAP_AREQ:
                if (length - (p - p0) < 1)
                        return;

-               TCHECK(*p);
+               ND_TCHECK(*p);

                peerid_len = *p;        /* Peer-ID Length */
                p++;
                if (length - (p - p0) < peerid_len)
                        return;
                peerid_len = *p;        /* Peer-ID Length */
                p++;
                if (length - (p - p0) < peerid_len)
                        return;

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

                for (i = 0; i < peerid_len; i++) {
                for (i = 0; i < peerid_len; i++) {

-                       TCHECK(*p);
-                       safeputchar(gndo, *p++);
+                       ND_TCHECK(*p);
+                       safeputchar(ndo, *p++);

                }
 
                if (length - (p - p0) < 1)
                        return;
                }
 
                if (length - (p - p0) < 1)
                        return;

-               TCHECK(*p);
+               ND_TCHECK(*p);

                passwd_len = *p;        /* Password Length */
                p++;
                if (length - (p - p0) < passwd_len)
                        return;
                passwd_len = *p;        /* Password Length */
                p++;
                if (length - (p - p0) < passwd_len)
                        return;

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

                for (i = 0; i < passwd_len; i++) {
                for (i = 0; i < passwd_len; i++) {

-                       TCHECK(*p);
-                       safeputchar(gndo, *p++);
+                       ND_TCHECK(*p);
+                       safeputchar(ndo, *p++);

                }
                break;
        case PAP_AACK:
        case PAP_ANAK:
                if (length - (p - p0) < 1)
                        return;
                }
                break;
        case PAP_AACK:
        case PAP_ANAK:
                if (length - (p - p0) < 1)
                        return;

-               TCHECK(*p);
+               ND_TCHECK(*p);

                msg_len = *p;           /* Msg-Length */
                p++;
                if (length - (p - p0) < msg_len)
                        return;
                msg_len = *p;           /* Msg-Length */
                p++;
                if (length - (p - p0) < msg_len)
                        return;

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

                for (i = 0; i< msg_len; i++) {
                for (i = 0; i< msg_len; i++) {

-                       TCHECK(*p);
-                       safeputchar(gndo, *p++);
+                       ND_TCHECK(*p);
+                       safeputchar(ndo, *p++);

                }
                break;
        }
        return;
 
 trunc:
                }
                break;
        }
        return;
 
 trunc:

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

 }
 
 /* BAP */
 static void
 }
 
 /* BAP */
 static void

-handle_bap(const u_char *p _U_, int length _U_)
+handle_bap(netdissect_options *ndo _U_,
+           const u_char *p _U_, int length _U_)

 {
        /* XXX: to be supported!! */
 }
 {
        /* XXX: to be supported!! */
 }


@@ -1003,53 +1002,54 @@ handle_bap(const u_char *p _U_, int length _U_)
 
 /* IPCP config options */
 static int
 
 /* IPCP config options */
 static int

-print_ipcp_config_options(const u_char *p, int length)
+print_ipcp_config_options(netdissect_options *ndo,
+                          const u_char *p, int length)

 {
        int len, opt;
         u_int compproto, ipcomp_subopttotallen, ipcomp_subopt, ipcomp_suboptlen;
 
        if (length < 2)
                return 0;
 {
        int len, opt;
         u_int compproto, ipcomp_subopttotallen, ipcomp_subopt, ipcomp_suboptlen;
 
        if (length < 2)
                return 0;

-       TCHECK2(*p, 2);
+       ND_TCHECK2(*p, 2);

        len = p[1];
        opt = p[0];
        if (length < len)
                return 0;
        if (len < 2) {
        len = p[1];
        opt = p[0];
        if (length < len)
                return 0;
        if (len < 2) {

-               printf("\n\t  %s Option (0x%02x), length %u (length bogus, should be >= 2)",
+               ND_PRINT((ndo, "\n\t  %s Option (0x%02x), length %u (length bogus, should be >= 2)",

                       tok2str(ipcpopt_values,"unknown",opt),
                       opt,
                       tok2str(ipcpopt_values,"unknown",opt),
                       opt,

-                      len);
+                      len));

                return 0;
        }
 
                return 0;
        }
 

-       printf("\n\t  %s Option (0x%02x), length %u",
+       ND_PRINT((ndo, "\n\t  %s Option (0x%02x), length %u",

               tok2str(ipcpopt_values,"unknown",opt),
               opt,
               tok2str(ipcpopt_values,"unknown",opt),
               opt,

-               len);
+              len));

 
        switch (opt) {
        case IPCPOPT_2ADDR:             /* deprecated */
                if (len != 10) {
 
        switch (opt) {
        case IPCPOPT_2ADDR:             /* deprecated */
                if (len != 10) {

-                       printf(" (length bogus, should be = 10)");
+                       ND_PRINT((ndo, " (length bogus, should be = 10)"));

                        return len;
                }
                        return len;
                }

-               TCHECK2(*(p + 6), 4);
-               printf(": src %s, dst %s",
+               ND_TCHECK2(*(p + 6), 4);
+               ND_PRINT((ndo, ": src %s, dst %s",

                       ipaddr_string(p + 2),
                       ipaddr_string(p + 2),

-                      ipaddr_string(p + 6));
+                      ipaddr_string(p + 6)));

                break;
        case IPCPOPT_IPCOMP:
                if (len < 4) {
                break;
        case IPCPOPT_IPCOMP:
                if (len < 4) {

-                       printf(" (length bogus, should be >= 4)");
+                       ND_PRINT((ndo, " (length bogus, should be >= 4)"));

                        return 0;
                }
                        return 0;
                }

-               TCHECK2(*(p + 2), 2);
-                compproto = EXTRACT_16BITS(p+2);
+               ND_TCHECK2(*(p + 2), 2);
+               compproto = EXTRACT_16BITS(p+2);

 
 

-                printf(": %s (0x%02x):",
-                       tok2str(ipcpopt_compproto_values,"Unknown",compproto),
-                       compproto);
+               ND_PRINT((ndo, ": %s (0x%02x):",
+                         tok2str(ipcpopt_compproto_values, "Unknown", compproto),
+                         compproto));

 
                switch (compproto) {
                 case PPP_VJC:
 
                switch (compproto) {
                 case PPP_VJC:


@@ -1057,29 +1057,29 @@ print_ipcp_config_options(const u_char *p, int length)
                         break;
                 case IPCPOPT_IPCOMP_HDRCOMP:
                         if (len < IPCPOPT_IPCOMP_MINLEN) {
                         break;
                 case IPCPOPT_IPCOMP_HDRCOMP:
                         if (len < IPCPOPT_IPCOMP_MINLEN) {

-                               printf(" (length bogus, should be >= %u)",
-                                       IPCPOPT_IPCOMP_MINLEN);
+                               ND_PRINT((ndo, " (length bogus, should be >= %u)",
+                                       IPCPOPT_IPCOMP_MINLEN));

                                return 0;
                         }
 
                                return 0;
                         }
 

-                        TCHECK2(*(p + 2), IPCPOPT_IPCOMP_MINLEN);
-                        printf("\n\t    TCP Space %u, non-TCP Space %u" \
+                        ND_TCHECK2(*(p + 2), IPCPOPT_IPCOMP_MINLEN);
+                        ND_PRINT((ndo, "\n\t    TCP Space %u, non-TCP Space %u" \

                                ", maxPeriod %u, maxTime %u, maxHdr %u",
                                EXTRACT_16BITS(p+4),
                                EXTRACT_16BITS(p+6),
                                EXTRACT_16BITS(p+8),
                                EXTRACT_16BITS(p+10),
                                ", maxPeriod %u, maxTime %u, maxHdr %u",
                                EXTRACT_16BITS(p+4),
                                EXTRACT_16BITS(p+6),
                                EXTRACT_16BITS(p+8),
                                EXTRACT_16BITS(p+10),

-                               EXTRACT_16BITS(p+12));
+                               EXTRACT_16BITS(p+12)));

 
                         /* suboptions present ? */
                         if (len > IPCPOPT_IPCOMP_MINLEN) {
                                 ipcomp_subopttotallen = len - IPCPOPT_IPCOMP_MINLEN;
                                 p += IPCPOPT_IPCOMP_MINLEN;
 
 
                         /* suboptions present ? */
                         if (len > IPCPOPT_IPCOMP_MINLEN) {
                                 ipcomp_subopttotallen = len - IPCPOPT_IPCOMP_MINLEN;
                                 p += IPCPOPT_IPCOMP_MINLEN;
 

-                                printf("\n\t      Suboptions, length %u", ipcomp_subopttotallen);
+                                ND_PRINT((ndo, "\n\t      Suboptions, length %u", ipcomp_subopttotallen));

 
                                 while (ipcomp_subopttotallen >= 2) {
 
                                 while (ipcomp_subopttotallen >= 2) {

-                                        TCHECK2(*p, 2);
+                                        ND_TCHECK2(*p, 2);

                                         ipcomp_subopt = *p;
                                         ipcomp_suboptlen = *(p+1);
 
                                         ipcomp_subopt = *p;
                                         ipcomp_suboptlen = *(p+1);
 


@@ -1089,12 +1089,12 @@ print_ipcp_config_options(const u_char *p, int length)
                                                 break;
 
                                         /* XXX: just display the suboptions for now */
                                                 break;
 
                                         /* XXX: just display the suboptions for now */

-                                        printf("\n\t\t%s Suboption #%u, length %u",
+                                        ND_PRINT((ndo, "\n\t\t%s Suboption #%u, length %u",

                                                tok2str(ipcpopt_compproto_subopt_values,
                                                        "Unknown",
                                                        ipcomp_subopt),
                                                ipcomp_subopt,
                                                tok2str(ipcpopt_compproto_subopt_values,
                                                        "Unknown",
                                                        ipcomp_subopt),
                                                ipcomp_subopt,

-                                               ipcomp_suboptlen);
+                                               ipcomp_suboptlen));

 
                                         ipcomp_subopttotallen -= ipcomp_suboptlen;
                                         p += ipcomp_suboptlen;
 
                                         ipcomp_subopttotallen -= ipcomp_suboptlen;
                                         p += ipcomp_suboptlen;


@@ -1113,146 +1113,148 @@ print_ipcp_config_options(const u_char *p, int length)
        case IPCPOPT_SECDNS:
        case IPCPOPT_SECNBNS:
                if (len != 6) {
        case IPCPOPT_SECDNS:
        case IPCPOPT_SECNBNS:
                if (len != 6) {

-                       printf(" (length bogus, should be = 6)");
+                       ND_PRINT((ndo, " (length bogus, should be = 6)"));

                        return 0;
                }
                        return 0;
                }

-               TCHECK2(*(p + 2), 4);
-               printf(": %s", ipaddr_string(p + 2));
+               ND_TCHECK2(*(p + 2), 4);
+               ND_PRINT((ndo, ": %s", ipaddr_string(p + 2)));

                break;
        default:
                break;
        default:

-               /*
-                * Unknown option; dump it as raw bytes now if we're
-                * not going to do so below.
-                */
-                if(vflag<2)
-                        print_unknown_data(gndo,&p[2],"\n\t    ",len-2);
+               /*
+                * Unknown option; dump it as raw bytes now if we're
+                * not going to do so below.
+                */
+               if (ndo->ndo_vflag < 2)
+                       print_unknown_data(ndo, &p[2], "\n\t    ", len - 2);

                break;
        }
                break;
        }

-        if (vflag>1)
-                print_unknown_data(gndo,&p[2],"\n\t    ",len-2); /* exclude TLV header */
+       if (ndo->ndo_vflag > 1)
+               print_unknown_data(ndo, &p[2], "\n\t    ", len - 2); /* exclude TLV header */

        return len;
 
 trunc:
        return len;
 
 trunc:

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

        return 0;
 }
 
 /* IP6CP config options */
 static int
        return 0;
 }
 
 /* IP6CP config options */
 static int

-print_ip6cp_config_options(const u_char *p, int length)
+print_ip6cp_config_options(netdissect_options *ndo,
+                           const u_char *p, int length)

 {
        int len, opt;
 
        if (length < 2)
                return 0;
 {
        int len, opt;
 
        if (length < 2)
                return 0;

-       TCHECK2(*p, 2);
+       ND_TCHECK2(*p, 2);

        len = p[1];
        opt = p[0];
        if (length < len)
                return 0;
        if (len < 2) {
        len = p[1];
        opt = p[0];
        if (length < len)
                return 0;
        if (len < 2) {

-               printf("\n\t  %s Option (0x%02x), length %u (length bogus, should be >= 2)",
+               ND_PRINT((ndo, "\n\t  %s Option (0x%02x), length %u (length bogus, should be >= 2)",

                       tok2str(ip6cpopt_values,"unknown",opt),
                       opt,
                       tok2str(ip6cpopt_values,"unknown",opt),
                       opt,

-                      len);
-               return 0;
+                      len));
+               return 0;

        }
 
        }
 

-       printf("\n\t  %s Option (0x%02x), length %u",
+       ND_PRINT((ndo, "\n\t  %s Option (0x%02x), length %u",

               tok2str(ip6cpopt_values,"unknown",opt),
               opt,
               tok2str(ip6cpopt_values,"unknown",opt),
               opt,

-               len);
+              len));

 
        switch (opt) {
        case IP6CP_IFID:
                if (len != 10) {
 
        switch (opt) {
        case IP6CP_IFID:
                if (len != 10) {

-                       printf(" (length bogus, should be = 10)");
+                       ND_PRINT((ndo, " (length bogus, should be = 10)"));

                        return len;
                }
                        return len;
                }

-               TCHECK2(*(p + 2), 8);
-               printf(": %04x:%04x:%04x:%04x",
+               ND_TCHECK2(*(p + 2), 8);
+               ND_PRINT((ndo, ": %04x:%04x:%04x:%04x",

                       EXTRACT_16BITS(p + 2),
                       EXTRACT_16BITS(p + 4),
                       EXTRACT_16BITS(p + 6),
                       EXTRACT_16BITS(p + 2),
                       EXTRACT_16BITS(p + 4),
                       EXTRACT_16BITS(p + 6),

-                      EXTRACT_16BITS(p + 8));
+                      EXTRACT_16BITS(p + 8)));

                break;
        default:
                break;
        default:

-               /*
-                * Unknown option; dump it as raw bytes now if we're
-                * not going to do so below.
-                */
-                if(vflag<2)
-                        print_unknown_data(gndo,&p[2],"\n\t    ",len-2);
+               /*
+                * Unknown option; dump it as raw bytes now if we're
+                * not going to do so below.
+                */
+               if (ndo->ndo_vflag < 2)
+                       print_unknown_data(ndo, &p[2], "\n\t    ", len - 2);

                break;
        }
                break;
        }

-        if (vflag>1)
-                print_unknown_data(gndo,&p[2],"\n\t    ",len-2); /* exclude TLV header */
+       if (ndo->ndo_vflag > 1)
+               print_unknown_data(ndo, &p[2], "\n\t    ", len - 2); /* exclude TLV header */

 
        return len;
 
 trunc:
 
        return len;
 
 trunc:

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

        return 0;
 }
 
 
 /* CCP config options */
 static int
        return 0;
 }
 
 
 /* CCP config options */
 static int

-print_ccp_config_options(const u_char *p, int length)
+print_ccp_config_options(netdissect_options *ndo,
+                         const u_char *p, int length)

 {
        int len, opt;
 
        if (length < 2)
                return 0;
 {
        int len, opt;
 
        if (length < 2)
                return 0;

-       TCHECK2(*p, 2);
+       ND_TCHECK2(*p, 2);

        len = p[1];
        opt = p[0];
        if (length < len)
                return 0;
        if (len < 2) {
        len = p[1];
        opt = p[0];
        if (length < len)
                return 0;
        if (len < 2) {

-               printf("\n\t  %s Option (0x%02x), length %u (length bogus, should be >= 2)",
-                      tok2str(ccpconfopts_values, "Unknown", opt),
-                      opt,
-                      len);
-               return 0;
-        }
+               ND_PRINT((ndo, "\n\t  %s Option (0x%02x), length %u (length bogus, should be >= 2)",
+                         tok2str(ccpconfopts_values, "Unknown", opt),
+                         opt,
+                         len));
+               return 0;
+       }

 
 

-        printf("\n\t  %s Option (0x%02x), length %u",
-               tok2str(ccpconfopts_values, "Unknown", opt),
-               opt,
-               len);
+       ND_PRINT((ndo, "\n\t  %s Option (0x%02x), length %u",
+                 tok2str(ccpconfopts_values, "Unknown", opt),
+                 opt,
+                 len));

 
        switch (opt) {
        case CCPOPT_BSDCOMP:
                if (len < 3) {
 
        switch (opt) {
        case CCPOPT_BSDCOMP:
                if (len < 3) {

-                       printf(" (length bogus, should be >= 3)");
+                       ND_PRINT((ndo, " (length bogus, should be >= 3)"));

                        return len;
                }
                        return len;
                }

-               TCHECK2(*(p + 2), 1);
-               printf(": Version: %u, Dictionary Bits: %u",
-                       p[2] >> 5, p[2] & 0x1f);
+               ND_TCHECK2(*(p + 2), 1);
+               ND_PRINT((ndo, ": Version: %u, Dictionary Bits: %u",
+                       p[2] >> 5, p[2] & 0x1f));

                break;
        case CCPOPT_MVRCA:
                if (len < 4) {
                break;
        case CCPOPT_MVRCA:
                if (len < 4) {

-                       printf(" (length bogus, should be >= 4)");
+                       ND_PRINT((ndo, " (length bogus, should be >= 4)"));

                        return len;
                }
                        return len;
                }

-               TCHECK2(*(p + 2), 1);
-               printf(": Features: %u, PxP: %s, History: %u, #CTX-ID: %u",
+               ND_TCHECK2(*(p + 2), 1);
+               ND_PRINT((ndo, ": Features: %u, PxP: %s, History: %u, #CTX-ID: %u",

                                (p[2] & 0xc0) >> 5,
                                (p[2] & 0x200) ? "Enabled" : "Disabled",
                                (p[2] & 0xc0) >> 5,
                                (p[2] & 0x200) ? "Enabled" : "Disabled",

-                               p[2] & 0x1f, p[3]);
+                               p[2] & 0x1f, p[3]));

                break;
        case CCPOPT_DEFLATE:
                if (len < 4) {
                break;
        case CCPOPT_DEFLATE:
                if (len < 4) {

-                       printf(" (length bogus, should be >= 4)");
+                       ND_PRINT((ndo, " (length bogus, should be >= 4)"));

                        return len;
                }
                        return len;
                }

-               TCHECK2(*(p + 2), 1);
-               printf(": Window: %uK, Method: %s (0x%x), MBZ: %u, CHK: %u",
+               ND_TCHECK2(*(p + 2), 1);
+               ND_PRINT((ndo, ": Window: %uK, Method: %s (0x%x), MBZ: %u, CHK: %u",

                        (p[2] & 0xf0) >> 4,
                        ((p[2] & 0x0f) == 8) ? "zlib" : "unkown",
                        (p[2] & 0xf0) >> 4,
                        ((p[2] & 0x0f) == 8) ? "zlib" : "unkown",

-                       p[2] & 0x0f, (p[3] & 0xfc) >> 2, p[3] & 0x03);
+                       p[2] & 0x0f, (p[3] & 0xfc) >> 2, p[3] & 0x03));

                break;
 
 /* XXX: to be supported */
                break;
 
 /* XXX: to be supported */


@@ -1272,81 +1274,82 @@ print_ccp_config_options(const u_char *p, int length)
                break;
 #endif
        default:
                break;
 #endif
        default:

-               /*
-                * Unknown option; dump it as raw bytes now if we're
-                * not going to do so below.
-                */
-                if(vflag<2)
-                        print_unknown_data(gndo,&p[2],"\n\t    ",len-2);
+               /*
+                * Unknown option; dump it as raw bytes now if we're
+                * not going to do so below.
+                */
+               if (ndo->ndo_vflag < 2)
+                       print_unknown_data(ndo, &p[2], "\n\t    ", len - 2);

                break;
        }
                break;
        }

-        if (vflag>1)
-                print_unknown_data(gndo,&p[2],"\n\t    ",len-2); /* exclude TLV header */
+       if (ndo->ndo_vflag > 1)
+               print_unknown_data(ndo, &p[2], "\n\t    ", len - 2); /* exclude TLV header */

 
        return len;
 
 trunc:
 
        return len;
 
 trunc:

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

        return 0;
 }
 
 /* BACP config options */
 static int
        return 0;
 }
 
 /* BACP config options */
 static int

-print_bacp_config_options(const u_char *p, int length)
+print_bacp_config_options(netdissect_options *ndo,
+                          const u_char *p, int length)

 {
        int len, opt;
 
        if (length < 2)
                return 0;
 {
        int len, opt;
 
        if (length < 2)
                return 0;

-       TCHECK2(*p, 2);
+       ND_TCHECK2(*p, 2);

        len = p[1];
        opt = p[0];
        if (length < len)
                return 0;
        if (len < 2) {
        len = p[1];
        opt = p[0];
        if (length < len)
                return 0;
        if (len < 2) {

-               printf("\n\t  %s Option (0x%02x), length %u (length bogus, should be >= 2)",
-                      tok2str(bacconfopts_values, "Unknown", opt),
-                      opt,
-                      len);
-               return 0;
-        }
+               ND_PRINT((ndo, "\n\t  %s Option (0x%02x), length %u (length bogus, should be >= 2)",
+                         tok2str(bacconfopts_values, "Unknown", opt),
+                         opt,
+                         len));
+               return 0;
+       }

 
 

-        printf("\n\t  %s Option (0x%02x), length %u",
-               tok2str(bacconfopts_values, "Unknown", opt),
-               opt,
-               len);
+       ND_PRINT((ndo, "\n\t  %s Option (0x%02x), length %u",
+                 tok2str(bacconfopts_values, "Unknown", opt),
+                 opt,
+                 len));

 
        switch (opt) {
        case BACPOPT_FPEER:
                if (len != 6) {
 
        switch (opt) {
        case BACPOPT_FPEER:
                if (len != 6) {

-                       printf(" (length bogus, should be = 6)");
+                       ND_PRINT((ndo, " (length bogus, should be = 6)"));

                        return len;
                }
                        return len;
                }

-               TCHECK2(*(p + 2), 4);
-               printf(": Magic-Num 0x%08x", EXTRACT_32BITS(p + 2));
-                break;
+               ND_TCHECK2(*(p + 2), 4);
+               ND_PRINT((ndo, ": Magic-Num 0x%08x", EXTRACT_32BITS(p + 2)));
+               break;

        default:
        default:

-               /*
-                * Unknown option; dump it as raw bytes now if we're
-                * not going to do so below.
-                */
-                if(vflag<2)
-                        print_unknown_data(gndo,&p[2],"\n\t    ",len-2);
+               /*
+                * Unknown option; dump it as raw bytes now if we're
+                * not going to do so below.
+                */
+               if (ndo->ndo_vflag < 2)
+                       print_unknown_data(ndo, &p[2], "\n\t    ", len - 2);

                break;
        }
                break;
        }

-        if (vflag>1)
-                print_unknown_data(gndo,&p[2],"\n\t    ",len-2); /* exclude TLV header */
+       if (ndo->ndo_vflag > 1)
+               print_unknown_data(ndo, &p[2], "\n\t    ", len - 2); /* exclude TLV header */

 
        return len;
 
 trunc:
 
        return len;
 
 trunc:

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

        return 0;
 }
 
        return 0;
 }
 

-

 static void
 static void

-ppp_hdlc(const u_char *p, int length)
+ppp_hdlc(netdissect_options *ndo,
+         const u_char *p, int length)

 {
        u_char *b, *s, *t, c;
        int i, proto;
 {
        u_char *b, *s, *t, c;
        int i, proto;


@@ -1376,8 +1379,8 @@ ppp_hdlc(const u_char *p, int length)
                *t++ = c;
        }
 
                *t++ = c;
        }
 

-       se = snapend;
-       snapend = t;
+       se = ndo->ndo_snapend;
+       ndo->ndo_snapend = t;

        length = t - b;
 
         /* now lets guess about the payload codepoint format */
        length = t - b;
 
         /* now lets guess about the payload codepoint format */


@@ -1387,11 +1390,11 @@ ppp_hdlc(const u_char *p, int length)
 
         switch (proto) {
         case PPP_IP:
 
         switch (proto) {
         case PPP_IP:

-               ip_print(gndo, b+1, length - 1);
+               ip_print(ndo, b + 1, length - 1);

                goto cleanup;
 #ifdef INET6
         case PPP_IPV6:
                goto cleanup;
 #ifdef INET6
         case PPP_IPV6:

-               ip6_print(gndo, b+1, length - 1);
+               ip6_print(ndo, b + 1, length - 1);

                goto cleanup;
 #endif
         default: /* no luck - try next guess */
                goto cleanup;
 #endif
         default: /* no luck - try next guess */


@@ -1407,34 +1410,34 @@ ppp_hdlc(const u_char *p, int length)
             if (length < 4)
                 goto trunc;
             proto = EXTRACT_16BITS(b+2); /* load the PPP proto-id */
             if (length < 4)
                 goto trunc;
             proto = EXTRACT_16BITS(b+2); /* load the PPP proto-id */

-            handle_ppp(proto, b+4, length - 4);
+            handle_ppp(ndo, proto, b + 4, length - 4);

             break;
         default: /* last guess - proto must be a PPP proto-id */
             break;
         default: /* last guess - proto must be a PPP proto-id */

-            handle_ppp(proto, b+2, length - 2);
+            handle_ppp(ndo, proto, b + 2, length - 2);

             break;
         }
 
 cleanup:
             break;
         }
 
 cleanup:

-        snapend = se;
+       ndo->ndo_snapend = se;

        free(b);
         return;
 
 trunc:
        free(b);
         return;
 
 trunc:

-        snapend = se;
+       ndo->ndo_snapend = se;

        free(b);
        free(b);

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

 }
 
 
 /* PPP */
 static void
 }
 
 
 /* PPP */
 static void

-handle_ppp(u_int proto, const u_char *p, int length)
+handle_ppp(netdissect_options *ndo,
+           u_int proto, const u_char *p, int length)

 {
 {

-        if ((proto & 0xff00) == 0x7e00) {/* is this an escape code ? */
-            ppp_hdlc(p-1, length);
-            return;
-        }
+       if ((proto & 0xff00) == 0x7e00) { /* is this an escape code ? */
+               ppp_hdlc(ndo, p - 1, length);
+               return;
+       }

 
        switch (proto) {
        case PPP_LCP: /* fall through */
 
        switch (proto) {
        case PPP_LCP: /* fall through */


@@ -1444,55 +1447,56 @@ handle_ppp(u_int proto, const u_char *p, int length)
        case PPP_IPV6CP:
        case PPP_CCP:
        case PPP_BACP:
        case PPP_IPV6CP:
        case PPP_CCP:
        case PPP_BACP:

-               handle_ctrl_proto(proto, p, length);
+               handle_ctrl_proto(ndo, proto, p, length);
+               break;
+       case PPP_ML:
+               handle_mlppp(ndo, p, length);

                break;
                break;

-        case PPP_ML:
-                handle_mlppp(p, length);
-                break;

        case PPP_CHAP:
        case PPP_CHAP:

-               handle_chap(p, length);
+               handle_chap(ndo, p, length);

                break;
        case PPP_PAP:
                break;
        case PPP_PAP:

-               handle_pap(p, length);
+               handle_pap(ndo, p, length);

                break;
        case PPP_BAP:           /* XXX: not yet completed */
                break;
        case PPP_BAP:           /* XXX: not yet completed */

-               handle_bap(p, length);
+               handle_bap(ndo, p, length);

                break;
        case ETHERTYPE_IP:      /*XXX*/
         case PPP_VJNC:
        case PPP_IP:
                break;
        case ETHERTYPE_IP:      /*XXX*/
         case PPP_VJNC:
        case PPP_IP:

-               ip_print(gndo, p, length);
+               ip_print(ndo, p, length);

                break;
 #ifdef INET6
        case ETHERTYPE_IPV6:    /*XXX*/
        case PPP_IPV6:
                break;
 #ifdef INET6
        case ETHERTYPE_IPV6:    /*XXX*/
        case PPP_IPV6:

-               ip6_print(gndo, p, length);
+               ip6_print(ndo, p, length);

                break;
 #endif
        case ETHERTYPE_IPX:     /*XXX*/
        case PPP_IPX:
                break;
 #endif
        case ETHERTYPE_IPX:     /*XXX*/
        case PPP_IPX:

-               ipx_print(gndo, p, length);
+               ipx_print(ndo, p, length);

                break;
        case PPP_OSI:
                break;
        case PPP_OSI:

-               isoclns_print(gndo, p, length, length);
+               isoclns_print(ndo, p, length, length);

                break;
        case PPP_MPLS_UCAST:
        case PPP_MPLS_MCAST:
                break;
        case PPP_MPLS_UCAST:
        case PPP_MPLS_MCAST:

-               mpls_print(gndo, p, length);
+               mpls_print(ndo, p, length);

                break;
        case PPP_COMP:
                break;
        case PPP_COMP:

-               printf("compressed PPP data");
+               ND_PRINT((ndo, "compressed PPP data"));

                break;
        default:
                break;
        default:

-               printf("%s ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", proto));
-               print_unknown_data(gndo,p,"\n\t",length);
+               ND_PRINT((ndo, "%s ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", proto)));
+               print_unknown_data(ndo, p, "\n\t", length);

                break;
        }
 }
 
 /* Standard PPP printer */
 u_int
                break;
        }
 }
 
 /* Standard PPP printer */
 u_int

-ppp_print(register const u_char *p, u_int length)
+ppp_print(netdissect_options *ndo,
+          register const u_char *p, u_int length)

 {
        u_int proto,ppp_header;
         u_int olen = length; /* _o_riginal length */
 {
        u_int proto,ppp_header;
         u_int olen = length; /* _o_riginal length */


@@ -1504,18 +1508,18 @@ ppp_print(register const u_char *p, u_int length)
         */
        if (length < 2)
                goto trunc;
         */
        if (length < 2)
                goto trunc;

-       TCHECK2(*p, 2);
+       ND_TCHECK2(*p, 2);

         ppp_header = EXTRACT_16BITS(p);
 
         switch(ppp_header) {
         case (PPP_WITHDIRECTION_IN  << 8 | PPP_CONTROL):
         ppp_header = EXTRACT_16BITS(p);
 
         switch(ppp_header) {
         case (PPP_WITHDIRECTION_IN  << 8 | PPP_CONTROL):

-            if (eflag) printf("In  ");
+            if (ndo->ndo_eflag) ND_PRINT((ndo, "In  "));

             p += 2;
             length -= 2;
             hdr_len += 2;
             break;
         case (PPP_WITHDIRECTION_OUT << 8 | PPP_CONTROL):
             p += 2;
             length -= 2;
             hdr_len += 2;
             break;
         case (PPP_WITHDIRECTION_OUT << 8 | PPP_CONTROL):

-            if (eflag) printf("Out ");
+            if (ndo->ndo_eflag) ND_PRINT((ndo, "Out "));

             p += 2;
             length -= 2;
             hdr_len += 2;
             p += 2;
             length -= 2;
             hdr_len += 2;


@@ -1532,43 +1536,44 @@ ppp_print(register const u_char *p, u_int length)
 
        if (length < 2)
                goto trunc;
 
        if (length < 2)
                goto trunc;

-       TCHECK(*p);
+       ND_TCHECK(*p);

        if (*p % 2) {
                proto = *p;             /* PFC is used */
                p++;
                length--;
                hdr_len++;
        } else {
        if (*p % 2) {
                proto = *p;             /* PFC is used */
                p++;
                length--;
                hdr_len++;
        } else {

-               TCHECK2(*p, 2);
+               ND_TCHECK2(*p, 2);

                proto = EXTRACT_16BITS(p);
                p += 2;
                length -= 2;
                hdr_len += 2;
        }
 
                proto = EXTRACT_16BITS(p);
                p += 2;
                length -= 2;
                hdr_len += 2;
        }
 

-        if (eflag)
-            printf("%s (0x%04x), length %u: ",
-                   tok2str(ppptype2str, "unknown", proto),
-                   proto,
-                   olen);
+       if (ndo->ndo_eflag)
+               ND_PRINT((ndo, "%s (0x%04x), length %u: ",
+                         tok2str(ppptype2str, "unknown", proto),
+                         proto,
+                         olen));

 
 

-       handle_ppp(proto, p, length);
+       handle_ppp(ndo, proto, p, length);

        return (hdr_len);
 trunc:
        return (hdr_len);
 trunc:

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

        return (0);
 }
 
 
 /* PPP I/F printer */
 u_int
        return (0);
 }
 
 
 /* PPP I/F printer */
 u_int

-ppp_if_print(const struct pcap_pkthdr *h, register const u_char *p)
+ppp_if_print(netdissect_options *ndo,
+             const struct pcap_pkthdr *h, register const u_char *p)

 {
        register u_int length = h->len;
        register u_int caplen = h->caplen;
 
        if (caplen < PPP_HDRLEN) {
 {
        register u_int length = h->len;
        register u_int caplen = h->caplen;
 
        if (caplen < PPP_HDRLEN) {

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

                return (caplen);
        }
 
                return (caplen);
        }
 


@@ -1609,11 +1614,11 @@ ppp_if_print(const struct pcap_pkthdr *h, register const u_char *p)
         * (Is the Cisco framing in question what DLT_C_HDLC, in
         * BSD/OS, is?)
         */
         * (Is the Cisco framing in question what DLT_C_HDLC, in
         * BSD/OS, is?)
         */

-       if (eflag)
-               printf("%c %4d %02x ", p[0] ? 'O' : 'I', length, p[1]);
+       if (ndo->ndo_eflag)
+               ND_PRINT((ndo, "%c %4d %02x ", p[0] ? 'O' : 'I', length, p[1]));

 #endif
 
 #endif
 

-       ppp_print(p, length);
+       ppp_print(ndo, p, length);

 
        return (0);
 }
 
        return (0);
 }


@@ -1628,7 +1633,8 @@ ppp_if_print(const struct pcap_pkthdr *h, register const u_char *p)
  * This handles, for example, DLT_PPP_SERIAL in NetBSD.
  */
 u_int
  * This handles, for example, DLT_PPP_SERIAL in NetBSD.
  */
 u_int

-ppp_hdlc_if_print(const struct pcap_pkthdr *h, register const u_char *p)
+ppp_hdlc_if_print(netdissect_options *ndo,
+                  const struct pcap_pkthdr *h, register const u_char *p)

 {
        register u_int length = h->len;
        register u_int caplen = h->caplen;
 {
        register u_int length = h->len;
        register u_int caplen = h->caplen;


@@ -1636,7 +1642,7 @@ ppp_hdlc_if_print(const struct pcap_pkthdr *h, register const u_char *p)
        u_int hdrlen = 0;
 
        if (caplen < 2) {
        u_int hdrlen = 0;
 
        if (caplen < 2) {

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

                return (caplen);
        }
 
                return (caplen);
        }
 


@@ -1644,12 +1650,12 @@ ppp_hdlc_if_print(const struct pcap_pkthdr *h, register const u_char *p)
 
        case PPP_ADDRESS:
                if (caplen < 4) {
 
        case PPP_ADDRESS:
                if (caplen < 4) {

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

                        return (caplen);
                }
 
                        return (caplen);
                }
 

-               if (eflag)
-                       printf("%02x %02x %d ", p[0], p[1], length);
+               if (ndo->ndo_eflag)
+                       ND_PRINT((ndo, "%02x %02x %d ", p[0], p[1], length));

                p += 2;
                length -= 2;
                hdrlen += 2;
                p += 2;
                length -= 2;
                hdrlen += 2;


@@ -1658,18 +1664,18 @@ ppp_hdlc_if_print(const struct pcap_pkthdr *h, register const u_char *p)
                p += 2;
                length -= 2;
                hdrlen += 2;
                p += 2;
                length -= 2;
                hdrlen += 2;

-               printf("%s: ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", proto));
+               ND_PRINT((ndo, "%s: ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", proto)));

 
 

-               handle_ppp(proto, p, length);
+               handle_ppp(ndo, proto, p, length);

                break;
 
        case CHDLC_UNICAST:
        case CHDLC_BCAST:
                break;
 
        case CHDLC_UNICAST:
        case CHDLC_BCAST:

-               return (chdlc_if_print(gndo, h, p));
+               return (chdlc_if_print(ndo, h, p));

 
        default:
 
        default:

-               if (eflag)
-                       printf("%02x %02x %d ", p[0], p[1], length);
+               if (ndo->ndo_eflag)
+                       ND_PRINT((ndo, "%02x %02x %d ", p[0], p[1], length));

                p += 2;
                hdrlen += 2;
 
                p += 2;
                hdrlen += 2;
 


@@ -1678,7 +1684,7 @@ ppp_hdlc_if_print(const struct pcap_pkthdr *h, register const u_char *p)
                 * the next two octets as an Ethernet type; does that
                 * ever happen?
                 */
                 * the next two octets as an Ethernet type; does that
                 * ever happen?
                 */

-               printf("unknown addr %02x; ctrl %02x", p[0], p[1]);
+               ND_PRINT((ndo, "unknown addr %02x; ctrl %02x", p[0], p[1]));

                break;
        }
 
                break;
        }
 


@@ -1689,7 +1695,8 @@ ppp_hdlc_if_print(const struct pcap_pkthdr *h, register const u_char *p)
 
 /* BSD/OS specific PPP printer */
 u_int
 
 /* BSD/OS specific PPP printer */
 u_int

-ppp_bsdos_if_print(const struct pcap_pkthdr *h _U_, register const u_char *p _U_)
+ppp_bsdos_if_print(netdissect_options *ndo _U_,
+                   const struct pcap_pkthdr *h _U_, register const u_char *p _U_)

 {
        register int hdrlength;
 #ifdef __bsdi__
 {
        register int hdrlength;
 #ifdef __bsdi__


@@ -1700,7 +1707,7 @@ ppp_bsdos_if_print(const struct pcap_pkthdr *h _U_, register const u_char *p _U_
        int i;
 
        if (caplen < PPP_BSDI_HDRLEN) {
        int i;
 
        if (caplen < PPP_BSDI_HDRLEN) {

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

                return (caplen)
        }
 
                return (caplen)
        }
 


@@ -1708,34 +1715,34 @@ ppp_bsdos_if_print(const struct pcap_pkthdr *h _U_, register const u_char *p _U_
 
 #if 0
        if (p[0] == PPP_ADDRESS && p[1] == PPP_CONTROL) {
 
 #if 0
        if (p[0] == PPP_ADDRESS && p[1] == PPP_CONTROL) {

-               if (eflag)
-                       printf("%02x %02x ", p[0], p[1]);
+               if (ndo->ndo_eflag)
+                       ND_PRINT((ndo, "%02x %02x ", p[0], p[1]));

                p += 2;
                hdrlength = 2;
        }
 
                p += 2;
                hdrlength = 2;
        }
 

-       if (eflag)
-               printf("%d ", length);
+       if (ndo->ndo_eflag)
+               ND_PRINT((ndo, "%d ", length));

        /* Retrieve the protocol type */
        if (*p & 01) {
                /* Compressed protocol field */
                ptype = *p;
        /* Retrieve the protocol type */
        if (*p & 01) {
                /* Compressed protocol field */
                ptype = *p;

-               if (eflag)
-                       printf("%02x ", ptype);
+               if (ndo->ndo_eflag)
+                       ND_PRINT((ndo, "%02x ", ptype));

                p++;
                hdrlength += 1;
        } else {
                /* Un-compressed protocol field */
                ptype = EXTRACT_16BITS(p);
                p++;
                hdrlength += 1;
        } else {
                /* Un-compressed protocol field */
                ptype = EXTRACT_16BITS(p);

-               if (eflag)
-                       printf("%04x ", ptype);
+               if (ndo->ndo_eflag)
+                       ND_PRINT((ndo, "%04x ", ptype));

                p += 2;
                hdrlength += 2;
        }
 #else
        ptype = 0;      /*XXX*/
                p += 2;
                hdrlength += 2;
        }
 #else
        ptype = 0;      /*XXX*/

-       if (eflag)
-               printf("%c ", p[SLC_DIR] ? 'O' : 'I');
+       if (ndo->ndo_eflag)
+               ND_PRINT((ndo, "%c ", p[SLC_DIR] ? 'O' : 'I'));

        if (p[SLC_LLHL]) {
                /* link level header */
                struct ppp_header *ph;
        if (p[SLC_LLHL]) {
                /* link level header */
                struct ppp_header *ph;


@@ -1744,72 +1751,72 @@ ppp_bsdos_if_print(const struct pcap_pkthdr *h _U_, register const u_char *p _U_
                ph = (struct ppp_header *)q;
                if (ph->phdr_addr == PPP_ADDRESS
                 && ph->phdr_ctl == PPP_CONTROL) {
                ph = (struct ppp_header *)q;
                if (ph->phdr_addr == PPP_ADDRESS
                 && ph->phdr_ctl == PPP_CONTROL) {

-                       if (eflag)
-                               printf("%02x %02x ", q[0], q[1]);
+                       if (ndo->ndo_eflag)
+                               ND_PRINT((ndo, "%02x %02x ", q[0], q[1]));

                        ptype = EXTRACT_16BITS(&ph->phdr_type);
                        ptype = EXTRACT_16BITS(&ph->phdr_type);

-                       if (eflag && (ptype == PPP_VJC || ptype == PPP_VJNC)) {
-                               printf("%s ", tok2str(ppptype2str,
-                                               "proto-#%d", ptype));
+                       if (ndo->ndo_eflag && (ptype == PPP_VJC || ptype == PPP_VJNC)) {
+                               ND_PRINT((ndo, "%s ", tok2str(ppptype2str,
+                                               "proto-#%d", ptype)));

                        }
                } else {
                        }
                } else {

-                       if (eflag) {
-                               printf("LLH=[");
+                       if (ndo->ndo_eflag) {
+                               ND_PRINT((ndo, "LLH=["));

                                for (i = 0; i < p[SLC_LLHL]; i++)
                                for (i = 0; i < p[SLC_LLHL]; i++)

-                                       printf("%02x", q[i]);
-                               printf("] ");
+                                       ND_PRINT((ndo, "%02x", q[i]));
+                               ND_PRINT((ndo, "] "));

                        }
                }
        }
                        }
                }
        }

-       if (eflag)
-               printf("%d ", length);
+       if (ndo->ndo_eflag)
+               ND_PRINT((ndo, "%d ", length));

        if (p[SLC_CHL]) {
                q = p + SLC_BPFHDRLEN + p[SLC_LLHL];
 
                switch (ptype) {
                case PPP_VJC:
        if (p[SLC_CHL]) {
                q = p + SLC_BPFHDRLEN + p[SLC_LLHL];
 
                switch (ptype) {
                case PPP_VJC:

-                       ptype = vjc_print(gndo, q, ptype);
+                       ptype = vjc_print(ndo, q, ptype);

                        hdrlength = PPP_BSDI_HDRLEN;
                        p += hdrlength;
                        switch (ptype) {
                        case PPP_IP:
                        hdrlength = PPP_BSDI_HDRLEN;
                        p += hdrlength;
                        switch (ptype) {
                        case PPP_IP:

-                               ip_print(gndo, p, length);
+                               ip_print(ndo, p, length);

                                break;
 #ifdef INET6
                        case PPP_IPV6:
                                break;
 #ifdef INET6
                        case PPP_IPV6:

-                               ip6_print(gndo, p, length);
+                               ip6_print(ndo, p, length);

                                break;
 #endif
                        case PPP_MPLS_UCAST:
                        case PPP_MPLS_MCAST:
                                break;
 #endif
                        case PPP_MPLS_UCAST:
                        case PPP_MPLS_MCAST:

-                               mpls_print(gndo, p, length);
+                               mpls_print(ndo, p, length);

                                break;
                        }
                        goto printx;
                case PPP_VJNC:
                                break;
                        }
                        goto printx;
                case PPP_VJNC:

-                       ptype = vjc_print(gndo, q, ptype);
+                       ptype = vjc_print(ndo, q, ptype);

                        hdrlength = PPP_BSDI_HDRLEN;
                        p += hdrlength;
                        switch (ptype) {
                        case PPP_IP:
                        hdrlength = PPP_BSDI_HDRLEN;
                        p += hdrlength;
                        switch (ptype) {
                        case PPP_IP:

-                               ip_print(gndo, p, length);
+                               ip_print(ndo, p, length);

                                break;
 #ifdef INET6
                        case PPP_IPV6:
                                break;
 #ifdef INET6
                        case PPP_IPV6:

-                               ip6_print(gndo, p, length);
+                               ip6_print(ndo, p, length);

                                break;
 #endif
                        case PPP_MPLS_UCAST:
                        case PPP_MPLS_MCAST:
                                break;
 #endif
                        case PPP_MPLS_UCAST:
                        case PPP_MPLS_MCAST:

-                               mpls_print(gndo, p, length);
+                               mpls_print(ndo, p, length);

                                break;
                        }
                        goto printx;
                default:
                                break;
                        }
                        goto printx;
                default:

-                       if (eflag) {
-                               printf("CH=[");
+                       if (ndo->ndo_eflag) {
+                               ND_PRINT((ndo, "CH=["));

                                for (i = 0; i < p[SLC_LLHL]; i++)
                                for (i = 0; i < p[SLC_LLHL]; i++)

-                                       printf("%02x", q[i]);
-                               printf("] ");
+                                       ND_PRINT((ndo, "%02x", q[i]));
+                               ND_PRINT((ndo, "] "));

                        }
                        break;
                }
                        }
                        break;
                }


@@ -1827,15 +1834,15 @@ ppp_bsdos_if_print(const struct pcap_pkthdr *h _U_, register const u_char *p _U_
                break;
 #ifdef INET6
        case PPP_IPV6:
                break;
 #ifdef INET6
        case PPP_IPV6:

-               ip6_print(gndo, p, length);
+               ip6_print(ndo, p, length);

                break;
 #endif
                break;
 #endif

-        case PPP_MPLS_UCAST:
-        case PPP_MPLS_MCAST:
-                mpls_print(gndo, p, length);
-                break;
+       case PPP_MPLS_UCAST:
+       case PPP_MPLS_MCAST:
+               mpls_print(ndo, p, length);
+               break;

        default:
        default:

-               printf("%s ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", ptype));
+               ND_PRINT((ndo, "%s ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", ptype)));

        }
 
 printx:
        }
 
 printx:

diff --git a/print-pppoe.c b/print-pppoe.c
index eae5ac4e7f19dd2d0305573e0b6a9ee70cdd25de..a59e141c6a5c74c82672b58b4237c010e173c990 100644 (file)
--- a/print-pppoe.c
+++ b/print-pppoe.c
@@ -191,7 +191,7 @@ pppoe_print(netdissect_options *ndo, register const u_char *bp, u_int length)
        } else {
                /* PPPoE data */
                ND_PRINT((ndo, " "));
        } else {
                /* PPPoE data */
                ND_PRINT((ndo, " "));

-               return (PPPOE_HDRLEN + ppp_print(pppoe_payload, pppoe_length));
+               return (PPPOE_HDRLEN + ppp_print(ndo, pppoe_payload, pppoe_length));

        }
 
 trunc:
        }
 
 trunc:

diff --git a/print-rsvp.c b/print-rsvp.c
index adf1829b19a24c23e600dad58b80487fbbaf57a9..e869b970875917fe2157fdfcb1d5c04bf311745a 100644 (file)
--- a/print-rsvp.c
+++ b/print-rsvp.c
@@ -15,16 +15,13 @@
  * Original code by Hannes Gredler ([email protected])
  */
 
  * Original code by Hannes Gredler ([email protected])
  */
 

+#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 <stdlib.h>
-#include <string.h>
-

 #include "interface.h"
 #include "extract.h"
 #include "addrtoname.h"
 #include "interface.h"
 #include "extract.h"
 #include "addrtoname.h"


@@ -481,8 +478,6 @@ static const struct tok rsvp_obj_generalized_uni_values[] = {
     { 0, NULL}
 };
 
     { 0, NULL}
 };
 

-static int rsvp_intserv_print(const u_char *, u_short);
-

 /*
  * this is a dissector for all the intserv defined
  * specs as defined per rfc2215
 /*
  * this is a dissector for all the intserv defined
  * specs as defined per rfc2215


@@ -490,7 +485,8 @@ static int rsvp_intserv_print(const u_char *, u_short);
  * returns the amount of bytes being processed
  */
 static int
  * returns the amount of bytes being processed
  */
 static int

-rsvp_intserv_print(const u_char *tptr, u_short obj_tlen) {
+rsvp_intserv_print(netdissect_options *ndo,
+                   const u_char *tptr, u_short obj_tlen) {

 
     int parameter_id,parameter_length;
     union {
 
     int parameter_id,parameter_length;
     union {


@@ -503,11 +499,11 @@ rsvp_intserv_print(const u_char *tptr, u_short obj_tlen) {
     parameter_id = *(tptr);
     parameter_length = EXTRACT_16BITS(tptr+2)<<2; /* convert wordcount to bytecount */
 
     parameter_id = *(tptr);
     parameter_length = EXTRACT_16BITS(tptr+2)<<2; /* convert wordcount to bytecount */
 

-    printf("\n\t      Parameter ID: %s (%u), length: %u, Flags: [0x%02x]",
+    ND_PRINT((ndo, "\n\t      Parameter ID: %s (%u), length: %u, Flags: [0x%02x]",

            tok2str(rsvp_intserv_parameter_id_values,"unknown",parameter_id),
            parameter_id,
            parameter_length,
            tok2str(rsvp_intserv_parameter_id_values,"unknown",parameter_id),
            parameter_id,
            parameter_length,

-           *(tptr+1));
+           *(tptr + 1)));

 
     if (obj_tlen < parameter_length+4)
         return 0;
 
     if (obj_tlen < parameter_length+4)
         return 0;


@@ -522,7 +518,7 @@ rsvp_intserv_print(const u_char *tptr, u_short obj_tlen) {
         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         */
         if (parameter_length == 4)
         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         */
         if (parameter_length == 4)

-            printf("\n\t\tIS hop count: %u", EXTRACT_32BITS(tptr+4));
+            ND_PRINT((ndo, "\n\t\tIS hop count: %u", EXTRACT_32BITS(tptr + 4)));

         break;
 
     case 6:
         break;
 
     case 6:


@@ -535,7 +531,7 @@ rsvp_intserv_print(const u_char *tptr, u_short obj_tlen) {
         */
         if (parameter_length == 4) {
             bw.i = EXTRACT_32BITS(tptr+4);
         */
         if (parameter_length == 4) {
             bw.i = EXTRACT_32BITS(tptr+4);

-            printf("\n\t\tPath b/w estimate: %.10g Mbps", bw.f/125000);
+            ND_PRINT((ndo, "\n\t\tPath b/w estimate: %.10g Mbps", bw.f / 125000));

         }
         break;
 
         }
         break;
 


@@ -548,11 +544,11 @@ rsvp_intserv_print(const u_char *tptr, u_short obj_tlen) {
         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         */
         if (parameter_length == 4) {
         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         */
         if (parameter_length == 4) {

-            printf("\n\t\tMinimum path latency: ");
+            ND_PRINT((ndo, "\n\t\tMinimum path latency: "));

             if (EXTRACT_32BITS(tptr+4) == 0xffffffff)
             if (EXTRACT_32BITS(tptr+4) == 0xffffffff)

-                printf("don't care");
+                ND_PRINT((ndo, "don't care"));

             else
             else

-                printf("%u", EXTRACT_32BITS(tptr+4));
+                ND_PRINT((ndo, "%u", EXTRACT_32BITS(tptr + 4)));

         }
         break;
 
         }
         break;
 


@@ -566,7 +562,7 @@ rsvp_intserv_print(const u_char *tptr, u_short obj_tlen) {
         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         */
         if (parameter_length == 4)
         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         */
         if (parameter_length == 4)

-            printf("\n\t\tComposed MTU: %u bytes", EXTRACT_32BITS(tptr+4));
+            ND_PRINT((ndo, "\n\t\tComposed MTU: %u bytes", EXTRACT_32BITS(tptr + 4)));

         break;
     case 127:
        /*
         break;
     case 127:
        /*


@@ -587,13 +583,13 @@ rsvp_intserv_print(const u_char *tptr, u_short obj_tlen) {
 
         if (parameter_length == 20) {
             bw.i = EXTRACT_32BITS(tptr+4);
 
         if (parameter_length == 20) {
             bw.i = EXTRACT_32BITS(tptr+4);

-            printf("\n\t\tToken Bucket Rate: %.10g Mbps", bw.f/125000);
+            ND_PRINT((ndo, "\n\t\tToken Bucket Rate: %.10g Mbps", bw.f / 125000));

             bw.i = EXTRACT_32BITS(tptr+8);
             bw.i = EXTRACT_32BITS(tptr+8);

-            printf("\n\t\tToken Bucket Size: %.10g bytes", bw.f);
+            ND_PRINT((ndo, "\n\t\tToken Bucket Size: %.10g bytes", bw.f));

             bw.i = EXTRACT_32BITS(tptr+12);
             bw.i = EXTRACT_32BITS(tptr+12);

-            printf("\n\t\tPeak Data Rate: %.10g Mbps", bw.f/125000);
-            printf("\n\t\tMinimum Policed Unit: %u bytes", EXTRACT_32BITS(tptr+16));
-            printf("\n\t\tMaximum Packet Size: %u bytes", EXTRACT_32BITS(tptr+20));
+            ND_PRINT((ndo, "\n\t\tPeak Data Rate: %.10g Mbps", bw.f / 125000));
+            ND_PRINT((ndo, "\n\t\tMinimum Policed Unit: %u bytes", EXTRACT_32BITS(tptr + 16)));
+            ND_PRINT((ndo, "\n\t\tMaximum Packet Size: %u bytes", EXTRACT_32BITS(tptr + 20)));

         }
         break;
 
         }
         break;
 


@@ -610,8 +606,8 @@ rsvp_intserv_print(const u_char *tptr, u_short obj_tlen) {
 
         if (parameter_length == 8) {
             bw.i = EXTRACT_32BITS(tptr+4);
 
         if (parameter_length == 8) {
             bw.i = EXTRACT_32BITS(tptr+4);

-            printf("\n\t\tRate: %.10g Mbps", bw.f/125000);
-            printf("\n\t\tSlack Term: %u", EXTRACT_32BITS(tptr+8));
+            ND_PRINT((ndo, "\n\t\tRate: %.10g Mbps", bw.f / 125000));
+            ND_PRINT((ndo, "\n\t\tSlack Term: %u", EXTRACT_32BITS(tptr + 8)));

         }
         break;
 
         }
         break;
 


@@ -620,18 +616,19 @@ rsvp_intserv_print(const u_char *tptr, u_short obj_tlen) {
     case 135:
     case 136:
         if (parameter_length == 4)
     case 135:
     case 136:
         if (parameter_length == 4)

-            printf("\n\t\tValue: %u", EXTRACT_32BITS(tptr+4));
+            ND_PRINT((ndo, "\n\t\tValue: %u", EXTRACT_32BITS(tptr + 4)));

         break;
 
     default:
         break;
 
     default:

-        if (vflag <= 1)
-            print_unknown_data(gndo,tptr+4,"\n\t\t",parameter_length);
+        if (ndo->ndo_vflag <= 1)
+            print_unknown_data(ndo, tptr + 4, "\n\t\t", parameter_length);

     }
     return (parameter_length+4); /* header length 4 bytes */
 }
 
 static int
     }
     return (parameter_length+4); /* header length 4 bytes */
 }
 
 static int

-rsvp_obj_print (const u_char *pptr
+rsvp_obj_print(netdissect_options *ndo,
+                const u_char *pptr

 #ifndef HAVE_LIBCRYPTO
 _U_
 #endif
 #ifndef HAVE_LIBCRYPTO
 _U_
 #endif


@@ -661,7 +658,7 @@ _U_
 
     while(tlen>=sizeof(struct rsvp_object_header)) {
         /* did we capture enough for fully decoding the object header ? */
 
     while(tlen>=sizeof(struct rsvp_object_header)) {
         /* did we capture enough for fully decoding the object header ? */

-        if (!TTEST2(*tptr, sizeof(struct rsvp_object_header)))
+        if (!ND_TTEST2(*tptr, sizeof(struct rsvp_object_header)))

             goto trunc;
 
         rsvp_obj_header = (const struct rsvp_object_header *)tptr;
             goto trunc;
 
         rsvp_obj_header = (const struct rsvp_object_header *)tptr;


@@ -669,36 +666,36 @@ _U_
         rsvp_obj_ctype=rsvp_obj_header->ctype;
 
         if(rsvp_obj_len % 4) {
         rsvp_obj_ctype=rsvp_obj_header->ctype;
 
         if(rsvp_obj_len % 4) {

-            printf("%sERROR: object header size %u not a multiple of 4", ident, rsvp_obj_len);
+            ND_PRINT((ndo, "%sERROR: object header size %u not a multiple of 4", ident, rsvp_obj_len));

             return -1;
         }
         if(rsvp_obj_len < sizeof(struct rsvp_object_header)) {
             return -1;
         }
         if(rsvp_obj_len < sizeof(struct rsvp_object_header)) {

-            printf("%sERROR: object header too short %u < %lu", ident, rsvp_obj_len,
-                   (unsigned long)sizeof(const struct rsvp_object_header));
+            ND_PRINT((ndo, "%sERROR: object header too short %u < %lu", ident, rsvp_obj_len,
+                   (unsigned long)sizeof(const struct rsvp_object_header)));

             return -1;
         }
 
             return -1;
         }
 

-        printf("%s%s Object (%u) Flags: [%s",
+        ND_PRINT((ndo, "%s%s Object (%u) Flags: [%s",

                ident,
                tok2str(rsvp_obj_values,
                        "Unknown",
                        rsvp_obj_header->class_num),
                rsvp_obj_header->class_num,
                ident,
                tok2str(rsvp_obj_values,
                        "Unknown",
                        rsvp_obj_header->class_num),
                rsvp_obj_header->class_num,

-               ((rsvp_obj_header->class_num)&0x80) ? "ignore" : "reject");
+               ((rsvp_obj_header->class_num) & 0x80) ? "ignore" : "reject"));

 
         if (rsvp_obj_header->class_num > 128)
 
         if (rsvp_obj_header->class_num > 128)

-            printf(" %s",
-                   ((rsvp_obj_header->class_num)&0x40) ? "and forward" : "silently");
+            ND_PRINT((ndo, " %s",
+                   ((rsvp_obj_header->class_num) & 0x40) ? "and forward" : "silently"));

 
 

-        printf(" if unknown], Class-Type: %s (%u), length: %u",
+        ND_PRINT((ndo, " if unknown], Class-Type: %s (%u), length: %u",

                tok2str(rsvp_ctype_values,
                        "Unknown",
                        ((rsvp_obj_header->class_num)<<8)+rsvp_obj_ctype),
                rsvp_obj_ctype,
                tok2str(rsvp_ctype_values,
                        "Unknown",
                        ((rsvp_obj_header->class_num)<<8)+rsvp_obj_ctype),
                rsvp_obj_ctype,

-               rsvp_obj_len);
+               rsvp_obj_len));

 
         if(tlen < rsvp_obj_len) {
 
         if(tlen < rsvp_obj_len) {

-            printf("%sERROR: object goes past end of objects TLV", ident);
+            ND_PRINT((ndo, "%sERROR: object goes past end of objects TLV", ident));

             return -1;
         }
 
             return -1;
         }
 


@@ -706,7 +703,7 @@ _U_
         obj_tlen=rsvp_obj_len-sizeof(struct rsvp_object_header);
 
         /* did we capture enough for fully decoding the object ? */
         obj_tlen=rsvp_obj_len-sizeof(struct rsvp_object_header);
 
         /* did we capture enough for fully decoding the object ? */

-        if (!TTEST2(*tptr, rsvp_obj_len))
+        if (!ND_TTEST2(*tptr, rsvp_obj_len))

             return -1;
         hexdump=FALSE;
 
             return -1;
         hexdump=FALSE;
 


@@ -716,14 +713,14 @@ _U_
             case RSVP_CTYPE_IPV4:
                 if (obj_tlen < 8)
                     return -1;
             case RSVP_CTYPE_IPV4:
                 if (obj_tlen < 8)
                     return -1;

-                printf("%s  IPv4 DestAddress: %s, Protocol ID: 0x%02x",
+                ND_PRINT((ndo, "%s  IPv4 DestAddress: %s, Protocol ID: 0x%02x",

                        ident,
                        ipaddr_string(obj_tptr),
                        ident,
                        ipaddr_string(obj_tptr),

-                       *(obj_tptr+sizeof(struct in_addr)));
-                printf("%s  Flags: [0x%02x], DestPort %u",
+                       *(obj_tptr + sizeof(struct in_addr))));
+                ND_PRINT((ndo, "%s  Flags: [0x%02x], DestPort %u",

                        ident,
                        *(obj_tptr+5),
                        ident,
                        *(obj_tptr+5),

-                       EXTRACT_16BITS(obj_tptr+6));
+                       EXTRACT_16BITS(obj_tptr + 6)));

                 obj_tlen-=8;
                 obj_tptr+=8;
                 break;
                 obj_tlen-=8;
                 obj_tptr+=8;
                 break;


@@ -731,14 +728,14 @@ _U_
             case RSVP_CTYPE_IPV6:
                 if (obj_tlen < 20)
                     return -1;
             case RSVP_CTYPE_IPV6:
                 if (obj_tlen < 20)
                     return -1;

-                printf("%s  IPv6 DestAddress: %s, Protocol ID: 0x%02x",
+                ND_PRINT((ndo, "%s  IPv6 DestAddress: %s, Protocol ID: 0x%02x",

                        ident,
                        ip6addr_string(obj_tptr),
                        ident,
                        ip6addr_string(obj_tptr),

-                       *(obj_tptr+sizeof(struct in6_addr)));
-                printf("%s  Flags: [0x%02x], DestPort %u",
+                       *(obj_tptr + sizeof(struct in6_addr))));
+                ND_PRINT((ndo, "%s  Flags: [0x%02x], DestPort %u",

                        ident,
                        *(obj_tptr+sizeof(struct in6_addr)+1),
                        ident,
                        *(obj_tptr+sizeof(struct in6_addr)+1),

-                       EXTRACT_16BITS(obj_tptr+sizeof(struct in6_addr)+2));
+                       EXTRACT_16BITS(obj_tptr + sizeof(struct in6_addr) + 2)));

                 obj_tlen-=20;
                 obj_tptr+=20;
                 break;
                 obj_tlen-=20;
                 obj_tptr+=20;
                 break;


@@ -746,11 +743,11 @@ _U_
             case RSVP_CTYPE_TUNNEL_IPV6:
                 if (obj_tlen < 36)
                     return -1;
             case RSVP_CTYPE_TUNNEL_IPV6:
                 if (obj_tlen < 36)
                     return -1;

-                printf("%s  IPv6 Tunnel EndPoint: %s, Tunnel ID: 0x%04x, Extended Tunnel ID: %s",
+                ND_PRINT((ndo, "%s  IPv6 Tunnel EndPoint: %s, Tunnel ID: 0x%04x, Extended Tunnel ID: %s",

                        ident,
                        ip6addr_string(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+18),
                        ident,
                        ip6addr_string(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+18),

-                       ip6addr_string(obj_tptr+20));
+                       ip6addr_string(obj_tptr + 20)));

                 obj_tlen-=36;
                 obj_tptr+=36;
                 break;
                 obj_tlen-=36;
                 obj_tptr+=36;
                 break;


@@ -758,11 +755,11 @@ _U_
             case RSVP_CTYPE_14: /* IPv6 p2mp LSP Tunnel */
                 if (obj_tlen < 26)
                     return -1;
             case RSVP_CTYPE_14: /* IPv6 p2mp LSP Tunnel */
                 if (obj_tlen < 26)
                     return -1;

-                printf("%s  IPv6 P2MP LSP ID: 0x%08x, Tunnel ID: 0x%04x, Extended Tunnel ID: %s",
+                ND_PRINT((ndo, "%s  IPv6 P2MP LSP ID: 0x%08x, Tunnel ID: 0x%04x, Extended Tunnel ID: %s",

                        ident,
                        EXTRACT_32BITS(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+6),
                        ident,
                        EXTRACT_32BITS(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+6),

-                       ip6addr_string(obj_tptr+8));
+                       ip6addr_string(obj_tptr + 8)));

                 obj_tlen-=26;
                 obj_tptr+=26;
                 break;
                 obj_tlen-=26;
                 obj_tptr+=26;
                 break;


@@ -770,11 +767,11 @@ _U_
             case RSVP_CTYPE_13: /* IPv4 p2mp LSP Tunnel */
                 if (obj_tlen < 12)
                     return -1;
             case RSVP_CTYPE_13: /* IPv4 p2mp LSP Tunnel */
                 if (obj_tlen < 12)
                     return -1;

-                printf("%s  IPv4 P2MP LSP ID: %s, Tunnel ID: 0x%04x, Extended Tunnel ID: %s",
+                ND_PRINT((ndo, "%s  IPv4 P2MP LSP ID: %s, Tunnel ID: 0x%04x, Extended Tunnel ID: %s",

                        ident,
                        ipaddr_string(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+6),
                        ident,
                        ipaddr_string(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+6),

-                       ipaddr_string(obj_tptr+8));
+                       ipaddr_string(obj_tptr + 8)));

                 obj_tlen-=12;
                 obj_tptr+=12;
                 break;
                 obj_tlen-=12;
                 obj_tptr+=12;
                 break;


@@ -782,11 +779,11 @@ _U_
             case RSVP_CTYPE_UNI_IPV4:
                 if (obj_tlen < 12)
                     return -1;
             case RSVP_CTYPE_UNI_IPV4:
                 if (obj_tlen < 12)
                     return -1;

-                printf("%s  IPv4 Tunnel EndPoint: %s, Tunnel ID: 0x%04x, Extended Tunnel ID: %s",
+                ND_PRINT((ndo, "%s  IPv4 Tunnel EndPoint: %s, Tunnel ID: 0x%04x, Extended Tunnel ID: %s",

                        ident,
                        ipaddr_string(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+6),
                        ident,
                        ipaddr_string(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+6),

-                       ipaddr_string(obj_tptr+8));
+                       ipaddr_string(obj_tptr + 8)));

                 obj_tlen-=12;
                 obj_tptr+=12;
                 break;
                 obj_tlen-=12;
                 obj_tptr+=12;
                 break;


@@ -800,9 +797,9 @@ _U_
             case RSVP_CTYPE_IPV4:
                 if (obj_tlen < sizeof(struct in_addr))
                     return -1;
             case RSVP_CTYPE_IPV4:
                 if (obj_tlen < sizeof(struct in_addr))
                     return -1;

-                printf("%s  IPv4 Receiver Address: %s",
+                ND_PRINT((ndo, "%s  IPv4 Receiver Address: %s",

                        ident,
                        ident,

-                       ipaddr_string(obj_tptr));
+                       ipaddr_string(obj_tptr)));

                 obj_tlen-=sizeof(struct in_addr);
                 obj_tptr+=sizeof(struct in_addr);
                 break;
                 obj_tlen-=sizeof(struct in_addr);
                 obj_tptr+=sizeof(struct in_addr);
                 break;


@@ -810,9 +807,9 @@ _U_
             case RSVP_CTYPE_IPV6:
                 if (obj_tlen < sizeof(struct in6_addr))
                     return -1;
             case RSVP_CTYPE_IPV6:
                 if (obj_tlen < sizeof(struct in6_addr))
                     return -1;

-                printf("%s  IPv6 Receiver Address: %s",
+                ND_PRINT((ndo, "%s  IPv6 Receiver Address: %s",

                        ident,
                        ident,

-                       ip6addr_string(obj_tptr));
+                       ip6addr_string(obj_tptr)));

                 obj_tlen-=sizeof(struct in6_addr);
                 obj_tptr+=sizeof(struct in6_addr);
                 break;
                 obj_tlen-=sizeof(struct in6_addr);
                 obj_tptr+=sizeof(struct in6_addr);
                 break;


@@ -827,9 +824,9 @@ _U_
             case RSVP_CTYPE_IPV4:
                 if (obj_tlen < sizeof(struct in_addr))
                     return -1;
             case RSVP_CTYPE_IPV4:
                 if (obj_tlen < sizeof(struct in_addr))
                     return -1;

-                printf("%s  IPv4 Notify Node Address: %s",
+                ND_PRINT((ndo, "%s  IPv4 Notify Node Address: %s",

                        ident,
                        ident,

-                       ipaddr_string(obj_tptr));
+                       ipaddr_string(obj_tptr)));

                 obj_tlen-=sizeof(struct in_addr);
                 obj_tptr+=sizeof(struct in_addr);
                 break;
                 obj_tlen-=sizeof(struct in_addr);
                 obj_tptr+=sizeof(struct in_addr);
                 break;


@@ -837,9 +834,9 @@ _U_
             case RSVP_CTYPE_IPV6:
                 if (obj_tlen < sizeof(struct in6_addr))
                     return-1;
             case RSVP_CTYPE_IPV6:
                 if (obj_tlen < sizeof(struct in6_addr))
                     return-1;

-                printf("%s  IPv6 Notify Node Address: %s",
+                ND_PRINT((ndo, "%s  IPv6 Notify Node Address: %s",

                        ident,
                        ident,

-                       ip6addr_string(obj_tptr));
+                       ip6addr_string(obj_tptr)));

                 obj_tlen-=sizeof(struct in6_addr);
                 obj_tptr+=sizeof(struct in6_addr);
                 break;
                 obj_tlen-=sizeof(struct in6_addr);
                 obj_tptr+=sizeof(struct in6_addr);
                 break;


@@ -856,7 +853,7 @@ _U_
             switch(rsvp_obj_ctype) {
             case RSVP_CTYPE_1:
                 while(obj_tlen >= 4 ) {
             switch(rsvp_obj_ctype) {
             case RSVP_CTYPE_1:
                 while(obj_tlen >= 4 ) {

-                    printf("%s  Label: %u", ident, EXTRACT_32BITS(obj_tptr));
+                    ND_PRINT((ndo, "%s  Label: %u", ident, EXTRACT_32BITS(obj_tptr)));

                     obj_tlen-=4;
                     obj_tptr+=4;
                 }
                     obj_tlen-=4;
                     obj_tptr+=4;
                 }


@@ -864,21 +861,21 @@ _U_
             case RSVP_CTYPE_2:
                 if (obj_tlen < 4)
                     return-1;
             case RSVP_CTYPE_2:
                 if (obj_tlen < 4)
                     return-1;

-                printf("%s  Generalized Label: %u",
+                ND_PRINT((ndo, "%s  Generalized Label: %u",

                        ident,
                        ident,

-                       EXTRACT_32BITS(obj_tptr));
+                       EXTRACT_32BITS(obj_tptr)));

                 obj_tlen-=4;
                 obj_tptr+=4;
                 break;
             case RSVP_CTYPE_3:
                 if (obj_tlen < 12)
                     return-1;
                 obj_tlen-=4;
                 obj_tptr+=4;
                 break;
             case RSVP_CTYPE_3:
                 if (obj_tlen < 12)
                     return-1;

-                printf("%s  Waveband ID: %u%s  Start Label: %u, Stop Label: %u",
+                ND_PRINT((ndo, "%s  Waveband ID: %u%s  Start Label: %u, Stop Label: %u",

                        ident,
                        EXTRACT_32BITS(obj_tptr),
                        ident,
                        EXTRACT_32BITS(obj_tptr+4),
                        ident,
                        EXTRACT_32BITS(obj_tptr),
                        ident,
                        EXTRACT_32BITS(obj_tptr+4),

-                       EXTRACT_32BITS(obj_tptr+8));
+                       EXTRACT_32BITS(obj_tptr + 8)));

                 obj_tlen-=12;
                 obj_tptr+=12;
                 break;
                 obj_tlen-=12;
                 obj_tptr+=12;
                 break;


@@ -892,12 +889,12 @@ _U_
             case RSVP_CTYPE_1:
                 if (obj_tlen < 4)
                     return-1;
             case RSVP_CTYPE_1:
                 if (obj_tlen < 4)
                     return-1;

-                printf("%s  Reservation Style: %s, Flags: [0x%02x]",
+                ND_PRINT((ndo, "%s  Reservation Style: %s, Flags: [0x%02x]",

                        ident,
                        tok2str(rsvp_resstyle_values,
                                "Unknown",
                                EXTRACT_24BITS(obj_tptr+1)),
                        ident,
                        tok2str(rsvp_resstyle_values,
                                "Unknown",
                                EXTRACT_24BITS(obj_tptr+1)),

-                       *(obj_tptr));
+                       *(obj_tptr)));

                 obj_tlen-=4;
                 obj_tptr+=4;
                 break;
                 obj_tlen-=4;
                 obj_tptr+=4;
                 break;


@@ -911,10 +908,10 @@ _U_
             case RSVP_CTYPE_IPV4:
                 if (obj_tlen < 8)
                     return-1;
             case RSVP_CTYPE_IPV4:
                 if (obj_tlen < 8)
                     return-1;

-                printf("%s  Source Address: %s, Source Port: %u",
+                ND_PRINT((ndo, "%s  Source Address: %s, Source Port: %u",

                        ident,
                        ipaddr_string(obj_tptr),
                        ident,
                        ipaddr_string(obj_tptr),

-                       EXTRACT_16BITS(obj_tptr+6));
+                       EXTRACT_16BITS(obj_tptr + 6)));

                 obj_tlen-=8;
                 obj_tptr+=8;
                 break;
                 obj_tlen-=8;
                 obj_tptr+=8;
                 break;


@@ -922,24 +919,24 @@ _U_
             case RSVP_CTYPE_IPV6:
                 if (obj_tlen < 20)
                     return-1;
             case RSVP_CTYPE_IPV6:
                 if (obj_tlen < 20)
                     return-1;

-                printf("%s  Source Address: %s, Source Port: %u",
+                ND_PRINT((ndo, "%s  Source Address: %s, Source Port: %u",

                        ident,
                        ip6addr_string(obj_tptr),
                        ident,
                        ip6addr_string(obj_tptr),

-                       EXTRACT_16BITS(obj_tptr+18));
+                       EXTRACT_16BITS(obj_tptr + 18)));

                 obj_tlen-=20;
                 obj_tptr+=20;
                 break;
             case RSVP_CTYPE_13: /* IPv6 p2mp LSP tunnel */
                 if (obj_tlen < 40)
                     return-1;
                 obj_tlen-=20;
                 obj_tptr+=20;
                 break;
             case RSVP_CTYPE_13: /* IPv6 p2mp LSP tunnel */
                 if (obj_tlen < 40)
                     return-1;

-                printf("%s  IPv6 Tunnel Sender Address: %s, LSP ID: 0x%04x"
+                ND_PRINT((ndo, "%s  IPv6 Tunnel Sender Address: %s, LSP ID: 0x%04x"

                        "%s  Sub-Group Originator ID: %s, Sub-Group ID: 0x%04x",
                        ident,
                        ip6addr_string(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+18),
                        ident,
                        ip6addr_string(obj_tptr+20),
                        "%s  Sub-Group Originator ID: %s, Sub-Group ID: 0x%04x",
                        ident,
                        ip6addr_string(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+18),
                        ident,
                        ip6addr_string(obj_tptr+20),

-                       EXTRACT_16BITS(obj_tptr+38));
+                       EXTRACT_16BITS(obj_tptr + 38)));

                 obj_tlen-=40;
                 obj_tptr+=40;
                 break;
                 obj_tlen-=40;
                 obj_tptr+=40;
                 break;


@@ -947,24 +944,24 @@ _U_
             case RSVP_CTYPE_TUNNEL_IPV4:
                 if (obj_tlen < 8)
                     return-1;
             case RSVP_CTYPE_TUNNEL_IPV4:
                 if (obj_tlen < 8)
                     return-1;

-                printf("%s  IPv4 Tunnel Sender Address: %s, LSP-ID: 0x%04x",
+                ND_PRINT((ndo, "%s  IPv4 Tunnel Sender Address: %s, LSP-ID: 0x%04x",

                        ident,
                        ipaddr_string(obj_tptr),
                        ident,
                        ipaddr_string(obj_tptr),

-                       EXTRACT_16BITS(obj_tptr+6));
+                       EXTRACT_16BITS(obj_tptr + 6)));

                 obj_tlen-=8;
                 obj_tptr+=8;
                 break;
             case RSVP_CTYPE_12: /* IPv4 p2mp LSP tunnel */
                 if (obj_tlen < 16)
                     return-1;
                 obj_tlen-=8;
                 obj_tptr+=8;
                 break;
             case RSVP_CTYPE_12: /* IPv4 p2mp LSP tunnel */
                 if (obj_tlen < 16)
                     return-1;

-                printf("%s  IPv4 Tunnel Sender Address: %s, LSP ID: 0x%04x"
+                ND_PRINT((ndo, "%s  IPv4 Tunnel Sender Address: %s, LSP ID: 0x%04x"

                        "%s  Sub-Group Originator ID: %s, Sub-Group ID: 0x%04x",
                        ident,
                        ipaddr_string(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+6),
                        ident,
                        ipaddr_string(obj_tptr+8),
                        "%s  Sub-Group Originator ID: %s, Sub-Group ID: 0x%04x",
                        ident,
                        ipaddr_string(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+6),
                        ident,
                        ipaddr_string(obj_tptr+8),

-                       EXTRACT_16BITS(obj_tptr+12));
+                       EXTRACT_16BITS(obj_tptr + 12)));

                 obj_tlen-=16;
                 obj_tptr+=16;
                 break;
                 obj_tlen-=16;
                 obj_tptr+=16;
                 break;


@@ -977,11 +974,11 @@ _U_
             switch(rsvp_obj_ctype) {
             case RSVP_CTYPE_1:
                 while(obj_tlen >= 4 ) {
             switch(rsvp_obj_ctype) {
             case RSVP_CTYPE_1:
                 while(obj_tlen >= 4 ) {

-                    printf("%s  L3 Protocol ID: %s",
+                    ND_PRINT((ndo, "%s  L3 Protocol ID: %s",

                            ident,
                            tok2str(ethertype_values,
                                    "Unknown Protocol (0x%04x)",
                            ident,
                            tok2str(ethertype_values,
                                    "Unknown Protocol (0x%04x)",

-                                   EXTRACT_16BITS(obj_tptr+2)));
+                                   EXTRACT_16BITS(obj_tptr + 2))));

                     obj_tlen-=4;
                     obj_tptr+=4;
                 }
                     obj_tlen-=4;
                     obj_tptr+=4;
                 }


@@ -989,50 +986,50 @@ _U_
             case RSVP_CTYPE_2:
                 if (obj_tlen < 12)
                     return-1;
             case RSVP_CTYPE_2:
                 if (obj_tlen < 12)
                     return-1;

-                printf("%s  L3 Protocol ID: %s",
+                ND_PRINT((ndo, "%s  L3 Protocol ID: %s",

                        ident,
                        tok2str(ethertype_values,
                                "Unknown Protocol (0x%04x)",
                        ident,
                        tok2str(ethertype_values,
                                "Unknown Protocol (0x%04x)",

-                               EXTRACT_16BITS(obj_tptr+2)));
-                printf(",%s merge capability",((*(obj_tptr+4))&0x80) ? "no" : "" );
-                printf("%s  Minimum VPI/VCI: %u/%u",
+                               EXTRACT_16BITS(obj_tptr + 2))));
+                ND_PRINT((ndo, ",%s merge capability",((*(obj_tptr + 4)) & 0x80) ? "no" : "" ));
+                ND_PRINT((ndo, "%s  Minimum VPI/VCI: %u/%u",

                        ident,
                        (EXTRACT_16BITS(obj_tptr+4))&0xfff,
                        ident,
                        (EXTRACT_16BITS(obj_tptr+4))&0xfff,

-                       (EXTRACT_16BITS(obj_tptr+6))&0xfff);
-                printf("%s  Maximum VPI/VCI: %u/%u",
+                       (EXTRACT_16BITS(obj_tptr + 6)) & 0xfff));
+                ND_PRINT((ndo, "%s  Maximum VPI/VCI: %u/%u",

                        ident,
                        (EXTRACT_16BITS(obj_tptr+8))&0xfff,
                        ident,
                        (EXTRACT_16BITS(obj_tptr+8))&0xfff,

-                       (EXTRACT_16BITS(obj_tptr+10))&0xfff);
+                       (EXTRACT_16BITS(obj_tptr + 10)) & 0xfff));

                 obj_tlen-=12;
                 obj_tptr+=12;
                 break;
             case RSVP_CTYPE_3:
                 if (obj_tlen < 12)
                     return-1;
                 obj_tlen-=12;
                 obj_tptr+=12;
                 break;
             case RSVP_CTYPE_3:
                 if (obj_tlen < 12)
                     return-1;

-                printf("%s  L3 Protocol ID: %s",
+                ND_PRINT((ndo, "%s  L3 Protocol ID: %s",

                        ident,
                        tok2str(ethertype_values,
                                "Unknown Protocol (0x%04x)",
                        ident,
                        tok2str(ethertype_values,
                                "Unknown Protocol (0x%04x)",

-                               EXTRACT_16BITS(obj_tptr+2)));
-                printf("%s  Minimum/Maximum DLCI: %u/%u, %s%s bit DLCI",
+                               EXTRACT_16BITS(obj_tptr + 2))));
+                ND_PRINT((ndo, "%s  Minimum/Maximum DLCI: %u/%u, %s%s bit DLCI",

                        ident,
                        (EXTRACT_32BITS(obj_tptr+4))&0x7fffff,
                        (EXTRACT_32BITS(obj_tptr+8))&0x7fffff,
                        (((EXTRACT_16BITS(obj_tptr+4)>>7)&3) == 0 ) ? "10" : "",
                        ident,
                        (EXTRACT_32BITS(obj_tptr+4))&0x7fffff,
                        (EXTRACT_32BITS(obj_tptr+8))&0x7fffff,
                        (((EXTRACT_16BITS(obj_tptr+4)>>7)&3) == 0 ) ? "10" : "",

-                       (((EXTRACT_16BITS(obj_tptr+4)>>7)&3) == 2 ) ? "23" : "");
+                       (((EXTRACT_16BITS(obj_tptr + 4) >> 7) & 3) == 2 ) ? "23" : ""));

                 obj_tlen-=12;
                 obj_tptr+=12;
                 break;
             case RSVP_CTYPE_4:
                 if (obj_tlen < 4)
                     return-1;
                 obj_tlen-=12;
                 obj_tptr+=12;
                 break;
             case RSVP_CTYPE_4:
                 if (obj_tlen < 4)
                     return-1;

-                printf("%s  LSP Encoding Type: %s (%u)",
+                ND_PRINT((ndo, "%s  LSP Encoding Type: %s (%u)",

                        ident,
                        tok2str(gmpls_encoding_values,
                                "Unknown",
                                *obj_tptr),
                        ident,
                        tok2str(gmpls_encoding_values,
                                "Unknown",
                                *obj_tptr),

-                      *obj_tptr);
-                printf("%s  Switching Type: %s (%u), Payload ID: %s (0x%04x)",
+                      *obj_tptr));
+                ND_PRINT((ndo, "%s  Switching Type: %s (%u), Payload ID: %s (0x%04x)",

                        ident,
                        tok2str(gmpls_switch_cap_values,
                                "Unknown",
                        ident,
                        tok2str(gmpls_switch_cap_values,
                                "Unknown",


@@ -1041,7 +1038,7 @@ _U_
                        tok2str(gmpls_payload_values,
                                "Unknown",
                                EXTRACT_16BITS(obj_tptr+2)),
                        tok2str(gmpls_payload_values,
                                "Unknown",
                                EXTRACT_16BITS(obj_tptr+2)),

-                      EXTRACT_16BITS(obj_tptr+2));
+                      EXTRACT_16BITS(obj_tptr + 2)));

                 obj_tlen-=4;
                 obj_tptr+=4;
                 break;
                 obj_tlen-=4;
                 obj_tptr+=4;
                 break;


@@ -1055,30 +1052,30 @@ _U_
             switch(rsvp_obj_ctype) {
             case RSVP_CTYPE_IPV4:
                 while(obj_tlen >= 4 ) {
             switch(rsvp_obj_ctype) {
             case RSVP_CTYPE_IPV4:
                 while(obj_tlen >= 4 ) {

-                    printf("%s  Subobject Type: %s, length %u",
+                    ND_PRINT((ndo, "%s  Subobject Type: %s, length %u",

                            ident,
                            tok2str(rsvp_obj_xro_values,
                                    "Unknown %u",
                                    RSVP_OBJ_XRO_MASK_SUBOBJ(*obj_tptr)),
                            ident,
                            tok2str(rsvp_obj_xro_values,
                                    "Unknown %u",
                                    RSVP_OBJ_XRO_MASK_SUBOBJ(*obj_tptr)),

-                           *(obj_tptr+1));
+                           *(obj_tptr + 1)));

 
                     if (*(obj_tptr+1) == 0) { /* prevent infinite loops */
 
                     if (*(obj_tptr+1) == 0) { /* prevent infinite loops */

-                        printf("%s  ERROR: zero length ERO subtype",ident);
+                        ND_PRINT((ndo, "%s  ERROR: zero length ERO subtype", ident));

                         break;
                     }
 
                     switch(RSVP_OBJ_XRO_MASK_SUBOBJ(*obj_tptr)) {
                     case RSVP_OBJ_XRO_IPV4:
                         break;
                     }
 
                     switch(RSVP_OBJ_XRO_MASK_SUBOBJ(*obj_tptr)) {
                     case RSVP_OBJ_XRO_IPV4:

-                        printf(", %s, %s/%u, Flags: [%s]",
+                        ND_PRINT((ndo, ", %s, %s/%u, Flags: [%s]",

                                RSVP_OBJ_XRO_MASK_LOOSE(*obj_tptr) ? "Loose" : "Strict",
                                ipaddr_string(obj_tptr+2),
                                *(obj_tptr+6),
                                bittok2str(rsvp_obj_rro_flag_values,
                                    "none",
                                RSVP_OBJ_XRO_MASK_LOOSE(*obj_tptr) ? "Loose" : "Strict",
                                ipaddr_string(obj_tptr+2),
                                *(obj_tptr+6),
                                bittok2str(rsvp_obj_rro_flag_values,
                                    "none",

-                                   *(obj_tptr+7))); /* rfc3209 says that this field is rsvd. */
+                                   *(obj_tptr + 7)))); /* rfc3209 says that this field is rsvd. */

                     break;
                     case RSVP_OBJ_XRO_LABEL:
                     break;
                     case RSVP_OBJ_XRO_LABEL:

-                        printf(", Flags: [%s] (%#x), Class-Type: %s (%u), %u",
+                        ND_PRINT((ndo, ", Flags: [%s] (%#x), Class-Type: %s (%u), %u",

                                bittok2str(rsvp_obj_rro_label_flag_values,
                                    "none",
                                    *(obj_tptr+2)),
                                bittok2str(rsvp_obj_rro_label_flag_values,
                                    "none",
                                    *(obj_tptr+2)),


@@ -1087,7 +1084,7 @@ _U_
                                        "Unknown",
                                        *(obj_tptr+3) + 256*RSVP_OBJ_RRO),
                                *(obj_tptr+3),
                                        "Unknown",
                                        *(obj_tptr+3) + 256*RSVP_OBJ_RRO),
                                *(obj_tptr+3),

-                               EXTRACT_32BITS(obj_tptr+4));
+                               EXTRACT_32BITS(obj_tptr + 4)));

                     }
                     obj_tlen-=*(obj_tptr+1);
                     obj_tptr+=*(obj_tptr+1);
                     }
                     obj_tlen-=*(obj_tptr+1);
                     obj_tptr+=*(obj_tptr+1);


@@ -1104,10 +1101,10 @@ _U_
             case RSVP_CTYPE_2:
                 if (obj_tlen < 8)
                     return-1;
             case RSVP_CTYPE_2:
                 if (obj_tlen < 8)
                     return-1;

-                printf("%s  Source Instance: 0x%08x, Destination Instance: 0x%08x",
+                ND_PRINT((ndo, "%s  Source Instance: 0x%08x, Destination Instance: 0x%08x",

                        ident,
                        EXTRACT_32BITS(obj_tptr),
                        ident,
                        EXTRACT_32BITS(obj_tptr),

-                       EXTRACT_32BITS(obj_tptr+4));
+                       EXTRACT_32BITS(obj_tptr + 4)));

                 obj_tlen-=8;
                 obj_tptr+=8;
                 break;
                 obj_tlen-=8;
                 obj_tptr+=8;
                 break;


@@ -1121,10 +1118,10 @@ _U_
             case RSVP_CTYPE_1:
                 if (obj_tlen < 8)
                     return-1;
             case RSVP_CTYPE_1:
                 if (obj_tlen < 8)
                     return-1;

-                printf("%s  Restart  Time: %ums, Recovery Time: %ums",
+                ND_PRINT((ndo, "%s  Restart  Time: %ums, Recovery Time: %ums",

                        ident,
                        EXTRACT_32BITS(obj_tptr),
                        ident,
                        EXTRACT_32BITS(obj_tptr),

-                       EXTRACT_32BITS(obj_tptr+4));
+                       EXTRACT_32BITS(obj_tptr + 4)));

                 obj_tlen-=8;
                 obj_tptr+=8;
                 break;
                 obj_tlen-=8;
                 obj_tptr+=8;
                 break;


@@ -1141,17 +1138,17 @@ _U_
                 namelen = *(obj_tptr+3);
                 if (obj_tlen < 4+namelen)
                     return-1;
                 namelen = *(obj_tptr+3);
                 if (obj_tlen < 4+namelen)
                     return-1;

-                printf("%s  Session Name: ", ident);
+                ND_PRINT((ndo, "%s  Session Name: ", ident));

                 for (i = 0; i < namelen; i++)
                 for (i = 0; i < namelen; i++)

-                    safeputchar(gndo, *(obj_tptr + 4 + i));
-                printf("%s  Setup Priority: %u, Holding Priority: %u, Flags: [%s] (%#x)",
+                    safeputchar(ndo, *(obj_tptr + 4 + i));
+                ND_PRINT((ndo, "%s  Setup Priority: %u, Holding Priority: %u, Flags: [%s] (%#x)",

                        ident,
                        (int)*obj_tptr,
                        (int)*(obj_tptr+1),
                        bittok2str(rsvp_session_attribute_flag_values,
                                   "none",
                                   *(obj_tptr+2)),
                        ident,
                        (int)*obj_tptr,
                        (int)*(obj_tptr+1),
                        bittok2str(rsvp_session_attribute_flag_values,
                                   "none",
                                   *(obj_tptr+2)),

-                       *(obj_tptr+2));
+                       *(obj_tptr + 2)));

                 obj_tlen-=4+*(obj_tptr+3);
                 obj_tptr+=4+*(obj_tptr+3);
                 break;
                 obj_tlen-=4+*(obj_tptr+3);
                 obj_tptr+=4+*(obj_tptr+3);
                 break;


@@ -1176,12 +1173,12 @@ _U_
                     subobj_type = (EXTRACT_16BITS(obj_tptr+2))>>8;
                     af = (EXTRACT_16BITS(obj_tptr+2))&0x00FF;
 
                     subobj_type = (EXTRACT_16BITS(obj_tptr+2))>>8;
                     af = (EXTRACT_16BITS(obj_tptr+2))&0x00FF;
 

-                    printf("%s  Subobject Type: %s (%u), AF: %s (%u), length: %u",
+                    ND_PRINT((ndo, "%s  Subobject Type: %s (%u), AF: %s (%u), length: %u",

                            ident,
                            tok2str(rsvp_obj_generalized_uni_values, "Unknown", subobj_type),
                            subobj_type,
                            tok2str(af_values, "Unknown", af), af,
                            ident,
                            tok2str(rsvp_obj_generalized_uni_values, "Unknown", subobj_type),
                            subobj_type,
                            tok2str(af_values, "Unknown", af), af,

-                           subobj_len);
+                           subobj_len));

 
                     switch(subobj_type) {
                     case RSVP_GEN_UNI_SUBOBJ_SOURCE_TNA_ADDRESS:
 
                     switch(subobj_type) {
                     case RSVP_GEN_UNI_SUBOBJ_SOURCE_TNA_ADDRESS:


@@ -1191,15 +1188,15 @@ _U_
                         case AFNUM_INET:
                             if (subobj_len < 8)
                                 return -1;
                         case AFNUM_INET:
                             if (subobj_len < 8)
                                 return -1;

-                            printf("%s    UNI IPv4 TNA address: %s",
-                                   ident, ipaddr_string(obj_tptr+4));
+                            ND_PRINT((ndo, "%s    UNI IPv4 TNA address: %s",
+                                   ident, ipaddr_string(obj_tptr + 4)));

                             break;
 #ifdef INET6
                         case AFNUM_INET6:
                             if (subobj_len < 20)
                                 return -1;
                             break;
 #ifdef INET6
                         case AFNUM_INET6:
                             if (subobj_len < 20)
                                 return -1;

-                            printf("%s    UNI IPv6 TNA address: %s",
-                                   ident, ip6addr_string(obj_tptr+4));
+                            ND_PRINT((ndo, "%s    UNI IPv6 TNA address: %s",
+                                   ident, ip6addr_string(obj_tptr + 4)));

                             break;
 #endif
                         case AFNUM_NSAP:
                             break;
 #endif
                         case AFNUM_NSAP:


@@ -1223,12 +1220,12 @@ _U_
                             return -1;
                         }
 
                             return -1;
                         }
 

-                        printf("%s    U-bit: %x, Label type: %u, Logical port id: %u, Label: %u",
+                        ND_PRINT((ndo, "%s    U-bit: %x, Label type: %u, Logical port id: %u, Label: %u",

                                ident,
                                ((EXTRACT_32BITS(obj_tptr+4))>>31),
                                ((EXTRACT_32BITS(obj_tptr+4))&0xFF),
                                EXTRACT_32BITS(obj_tptr+8),
                                ident,
                                ((EXTRACT_32BITS(obj_tptr+4))>>31),
                                ((EXTRACT_32BITS(obj_tptr+4))&0xFF),
                                EXTRACT_32BITS(obj_tptr+8),

-                               EXTRACT_32BITS(obj_tptr+12));
+                               EXTRACT_32BITS(obj_tptr + 12)));

                         break;
 
                     case RSVP_GEN_UNI_SUBOBJ_SERVICE_LEVEL:
                         break;
 
                     case RSVP_GEN_UNI_SUBOBJ_SERVICE_LEVEL:


@@ -1236,8 +1233,8 @@ _U_
                             return -1;
                         }
 
                             return -1;
                         }
 

-                        printf("%s    Service level: %u",
-                               ident, (EXTRACT_32BITS(obj_tptr+4))>>24);
+                        ND_PRINT((ndo, "%s    Service level: %u",
+                               ident, (EXTRACT_32BITS(obj_tptr + 4)) >> 24));

                         break;
 
                     default:
                         break;
 
                     default:


@@ -1266,10 +1263,10 @@ _U_
             case RSVP_CTYPE_IPV4:
                 if (obj_tlen < 8)
                     return-1;
             case RSVP_CTYPE_IPV4:
                 if (obj_tlen < 8)
                     return-1;

-                printf("%s  Previous/Next Interface: %s, Logical Interface Handle: 0x%08x",
+                ND_PRINT((ndo, "%s  Previous/Next Interface: %s, Logical Interface Handle: 0x%08x",

                        ident,
                        ipaddr_string(obj_tptr),
                        ident,
                        ipaddr_string(obj_tptr),

-                       EXTRACT_32BITS(obj_tptr+4));
+                       EXTRACT_32BITS(obj_tptr + 4)));

                 obj_tlen-=8;
                 obj_tptr+=8;
                 if (obj_tlen)
                 obj_tlen-=8;
                 obj_tptr+=8;
                 if (obj_tlen)


@@ -1280,10 +1277,10 @@ _U_
             case RSVP_CTYPE_IPV6:
                 if (obj_tlen < 20)
                     return-1;
             case RSVP_CTYPE_IPV6:
                 if (obj_tlen < 20)
                     return-1;

-                printf("%s  Previous/Next Interface: %s, Logical Interface Handle: 0x%08x",
+                ND_PRINT((ndo, "%s  Previous/Next Interface: %s, Logical Interface Handle: 0x%08x",

                        ident,
                        ip6addr_string(obj_tptr),
                        ident,
                        ip6addr_string(obj_tptr),

-                       EXTRACT_32BITS(obj_tptr+16));
+                       EXTRACT_32BITS(obj_tptr + 16)));

                 obj_tlen-=20;
                 obj_tptr+=20;
                 hexdump=TRUE; /* unless we have a TLV parser lets just hexdump */
                 obj_tlen-=20;
                 obj_tptr+=20;
                 hexdump=TRUE; /* unless we have a TLV parser lets just hexdump */


@@ -1299,9 +1296,9 @@ _U_
             case RSVP_CTYPE_1:
                 if (obj_tlen < 4)
                     return-1;
             case RSVP_CTYPE_1:
                 if (obj_tlen < 4)
                     return-1;

-                printf("%s  Refresh Period: %ums",
+                ND_PRINT((ndo, "%s  Refresh Period: %ums",

                        ident,
                        ident,

-                       EXTRACT_32BITS(obj_tptr));
+                       EXTRACT_32BITS(obj_tptr)));

                 obj_tlen-=4;
                 obj_tptr+=4;
                 break;
                 obj_tlen-=4;
                 obj_tptr+=4;
                 break;


@@ -1318,27 +1315,27 @@ _U_
             case RSVP_CTYPE_2:
                 if (obj_tlen < 4)
                     return-1;
             case RSVP_CTYPE_2:
                 if (obj_tlen < 4)
                     return-1;

-                printf("%s  Msg-Version: %u, length: %u",
+                ND_PRINT((ndo, "%s  Msg-Version: %u, length: %u",

                        ident,
                        (*obj_tptr & 0xf0) >> 4,
                        ident,
                        (*obj_tptr & 0xf0) >> 4,

-                       EXTRACT_16BITS(obj_tptr+2)<<2);
+                       EXTRACT_16BITS(obj_tptr + 2) << 2));

                 obj_tptr+=4; /* get to the start of the service header */
                 obj_tlen-=4;
 
                 while (obj_tlen >= 4) {
                     intserv_serv_tlen=EXTRACT_16BITS(obj_tptr+2)<<2;
                 obj_tptr+=4; /* get to the start of the service header */
                 obj_tlen-=4;
 
                 while (obj_tlen >= 4) {
                     intserv_serv_tlen=EXTRACT_16BITS(obj_tptr+2)<<2;

-                    printf("%s  Service Type: %s (%u), break bit %s set, Service length: %u",
+                    ND_PRINT((ndo, "%s  Service Type: %s (%u), break bit %s set, Service length: %u",

                            ident,
                            tok2str(rsvp_intserv_service_type_values,"unknown",*(obj_tptr)),
                            *(obj_tptr),
                            (*(obj_tptr+1)&0x80) ? "" : "not",
                            ident,
                            tok2str(rsvp_intserv_service_type_values,"unknown",*(obj_tptr)),
                            *(obj_tptr),
                            (*(obj_tptr+1)&0x80) ? "" : "not",

-                           intserv_serv_tlen);
+                           intserv_serv_tlen));

 
                     obj_tptr+=4; /* get to the start of the parameter list */
                     obj_tlen-=4;
 
                     while (intserv_serv_tlen>=4) {
 
                     obj_tptr+=4; /* get to the start of the parameter list */
                     obj_tlen-=4;
 
                     while (intserv_serv_tlen>=4) {

-                        processed = rsvp_intserv_print(obj_tptr, obj_tlen);
+                        processed = rsvp_intserv_print(ndo, obj_tptr, obj_tlen);

                         if (processed == 0)
                             break;
                         obj_tlen-=processed;
                         if (processed == 0)
                             break;
                         obj_tlen-=processed;


@@ -1357,10 +1354,10 @@ _U_
             case RSVP_CTYPE_IPV4:
                 if (obj_tlen < 8)
                     return-1;
             case RSVP_CTYPE_IPV4:
                 if (obj_tlen < 8)
                     return-1;

-                printf("%s  Source Address: %s, Source Port: %u",
+                ND_PRINT((ndo, "%s  Source Address: %s, Source Port: %u",

                        ident,
                        ipaddr_string(obj_tptr),
                        ident,
                        ipaddr_string(obj_tptr),

-                       EXTRACT_16BITS(obj_tptr+6));
+                       EXTRACT_16BITS(obj_tptr + 6)));

                 obj_tlen-=8;
                 obj_tptr+=8;
                 break;
                 obj_tlen-=8;
                 obj_tptr+=8;
                 break;


@@ -1368,44 +1365,44 @@ _U_
             case RSVP_CTYPE_IPV6:
                 if (obj_tlen < 20)
                     return-1;
             case RSVP_CTYPE_IPV6:
                 if (obj_tlen < 20)
                     return-1;

-                printf("%s  Source Address: %s, Source Port: %u",
+                ND_PRINT((ndo, "%s  Source Address: %s, Source Port: %u",

                        ident,
                        ip6addr_string(obj_tptr),
                        ident,
                        ip6addr_string(obj_tptr),

-                       EXTRACT_16BITS(obj_tptr+18));
+                       EXTRACT_16BITS(obj_tptr + 18)));

                 obj_tlen-=20;
                 obj_tptr+=20;
                 break;
             case RSVP_CTYPE_3:
                 if (obj_tlen < 20)
                     return-1;
                 obj_tlen-=20;
                 obj_tptr+=20;
                 break;
             case RSVP_CTYPE_3:
                 if (obj_tlen < 20)
                     return-1;

-                printf("%s  Source Address: %s, Flow Label: %u",
+                ND_PRINT((ndo, "%s  Source Address: %s, Flow Label: %u",

                        ident,
                        ip6addr_string(obj_tptr),
                        ident,
                        ip6addr_string(obj_tptr),

-                       EXTRACT_24BITS(obj_tptr+17));
+                       EXTRACT_24BITS(obj_tptr + 17)));

                 obj_tlen-=20;
                 obj_tptr+=20;
                 break;
             case RSVP_CTYPE_TUNNEL_IPV6:
                 if (obj_tlen < 20)
                     return-1;
                 obj_tlen-=20;
                 obj_tptr+=20;
                 break;
             case RSVP_CTYPE_TUNNEL_IPV6:
                 if (obj_tlen < 20)
                     return-1;

-                printf("%s  Source Address: %s, LSP-ID: 0x%04x",
+                ND_PRINT((ndo, "%s  Source Address: %s, LSP-ID: 0x%04x",

                        ident,
                        ipaddr_string(obj_tptr),
                        ident,
                        ipaddr_string(obj_tptr),

-                       EXTRACT_16BITS(obj_tptr+18));
+                       EXTRACT_16BITS(obj_tptr + 18)));

                 obj_tlen-=20;
                 obj_tptr+=20;
                 break;
             case RSVP_CTYPE_13: /* IPv6 p2mp LSP tunnel */
                 if (obj_tlen < 40)
                     return-1;
                 obj_tlen-=20;
                 obj_tptr+=20;
                 break;
             case RSVP_CTYPE_13: /* IPv6 p2mp LSP tunnel */
                 if (obj_tlen < 40)
                     return-1;

-                printf("%s  IPv6 Tunnel Sender Address: %s, LSP ID: 0x%04x"
+                ND_PRINT((ndo, "%s  IPv6 Tunnel Sender Address: %s, LSP ID: 0x%04x"

                        "%s  Sub-Group Originator ID: %s, Sub-Group ID: 0x%04x",
                        ident,
                        ip6addr_string(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+18),
                        ident,
                        ip6addr_string(obj_tptr+20),
                        "%s  Sub-Group Originator ID: %s, Sub-Group ID: 0x%04x",
                        ident,
                        ip6addr_string(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+18),
                        ident,
                        ip6addr_string(obj_tptr+20),

-                       EXTRACT_16BITS(obj_tptr+38));
+                       EXTRACT_16BITS(obj_tptr + 38)));

                 obj_tlen-=40;
                 obj_tptr+=40;
                 break;
                 obj_tlen-=40;
                 obj_tptr+=40;
                 break;


@@ -1413,24 +1410,24 @@ _U_
             case RSVP_CTYPE_TUNNEL_IPV4:
                 if (obj_tlen < 8)
                     return-1;
             case RSVP_CTYPE_TUNNEL_IPV4:
                 if (obj_tlen < 8)
                     return-1;

-                printf("%s  Source Address: %s, LSP-ID: 0x%04x",
+                ND_PRINT((ndo, "%s  Source Address: %s, LSP-ID: 0x%04x",

                        ident,
                        ipaddr_string(obj_tptr),
                        ident,
                        ipaddr_string(obj_tptr),

-                       EXTRACT_16BITS(obj_tptr+6));
+                       EXTRACT_16BITS(obj_tptr + 6)));

                 obj_tlen-=8;
                 obj_tptr+=8;
                 break;
             case RSVP_CTYPE_12: /* IPv4 p2mp LSP tunnel */
                 if (obj_tlen < 16)
                     return-1;
                 obj_tlen-=8;
                 obj_tptr+=8;
                 break;
             case RSVP_CTYPE_12: /* IPv4 p2mp LSP tunnel */
                 if (obj_tlen < 16)
                     return-1;

-                printf("%s  IPv4 Tunnel Sender Address: %s, LSP ID: 0x%04x"
+                ND_PRINT((ndo, "%s  IPv4 Tunnel Sender Address: %s, LSP ID: 0x%04x"

                        "%s  Sub-Group Originator ID: %s, Sub-Group ID: 0x%04x",
                        ident,
                        ipaddr_string(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+6),
                        ident,
                        ipaddr_string(obj_tptr+8),
                        "%s  Sub-Group Originator ID: %s, Sub-Group ID: 0x%04x",
                        ident,
                        ipaddr_string(obj_tptr),
                        EXTRACT_16BITS(obj_tptr+6),
                        ident,
                        ipaddr_string(obj_tptr+8),

-                       EXTRACT_16BITS(obj_tptr+12));
+                       EXTRACT_16BITS(obj_tptr + 12)));

                 obj_tlen-=16;
                 obj_tptr+=16;
                 break;
                 obj_tlen-=16;
                 obj_tptr+=16;
                 break;


@@ -1448,17 +1445,17 @@ _U_
             case RSVP_CTYPE_1: /* new style */
                 if (obj_tlen < sizeof(struct rsvp_obj_frr_t))
                     return-1;
             case RSVP_CTYPE_1: /* new style */
                 if (obj_tlen < sizeof(struct rsvp_obj_frr_t))
                     return-1;

-                printf("%s  Setup Priority: %u, Holding Priority: %u, Hop-limit: %u, Bandwidth: %.10g Mbps",
+                ND_PRINT((ndo, "%s  Setup Priority: %u, Holding Priority: %u, Hop-limit: %u, Bandwidth: %.10g Mbps",

                        ident,
                        (int)obj_ptr.rsvp_obj_frr->setup_prio,
                        (int)obj_ptr.rsvp_obj_frr->hold_prio,
                        (int)obj_ptr.rsvp_obj_frr->hop_limit,
                        ident,
                        (int)obj_ptr.rsvp_obj_frr->setup_prio,
                        (int)obj_ptr.rsvp_obj_frr->hold_prio,
                        (int)obj_ptr.rsvp_obj_frr->hop_limit,

-                        bw.f*8/1000000);
-                printf("%s  Include-any: 0x%08x, Exclude-any: 0x%08x, Include-all: 0x%08x",
+                        bw.f * 8 / 1000000));
+                ND_PRINT((ndo, "%s  Include-any: 0x%08x, Exclude-any: 0x%08x, Include-all: 0x%08x",

                        ident,
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_frr->include_any),
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_frr->exclude_any),
                        ident,
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_frr->include_any),
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_frr->exclude_any),

-                       EXTRACT_32BITS(obj_ptr.rsvp_obj_frr->include_all));
+                       EXTRACT_32BITS(obj_ptr.rsvp_obj_frr->include_all)));

                 obj_tlen-=sizeof(struct rsvp_obj_frr_t);
                 obj_tptr+=sizeof(struct rsvp_obj_frr_t);
                 break;
                 obj_tlen-=sizeof(struct rsvp_obj_frr_t);
                 obj_tptr+=sizeof(struct rsvp_obj_frr_t);
                 break;


@@ -1466,16 +1463,16 @@ _U_
             case RSVP_CTYPE_TUNNEL_IPV4: /* old style */
                 if (obj_tlen < 16)
                     return-1;
             case RSVP_CTYPE_TUNNEL_IPV4: /* old style */
                 if (obj_tlen < 16)
                     return-1;

-                printf("%s  Setup Priority: %u, Holding Priority: %u, Hop-limit: %u, Bandwidth: %.10g Mbps",
+                ND_PRINT((ndo, "%s  Setup Priority: %u, Holding Priority: %u, Hop-limit: %u, Bandwidth: %.10g Mbps",

                        ident,
                        (int)obj_ptr.rsvp_obj_frr->setup_prio,
                        (int)obj_ptr.rsvp_obj_frr->hold_prio,
                        (int)obj_ptr.rsvp_obj_frr->hop_limit,
                        ident,
                        (int)obj_ptr.rsvp_obj_frr->setup_prio,
                        (int)obj_ptr.rsvp_obj_frr->hold_prio,
                        (int)obj_ptr.rsvp_obj_frr->hop_limit,

-                        bw.f*8/1000000);
-                printf("%s  Include Colors: 0x%08x, Exclude Colors: 0x%08x",
+                        bw.f * 8 / 1000000));
+                ND_PRINT((ndo, "%s  Include Colors: 0x%08x, Exclude Colors: 0x%08x",

                        ident,
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_frr->include_any),
                        ident,
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_frr->include_any),

-                       EXTRACT_32BITS(obj_ptr.rsvp_obj_frr->exclude_any));
+                       EXTRACT_32BITS(obj_ptr.rsvp_obj_frr->exclude_any)));

                 obj_tlen-=16;
                 obj_tptr+=16;
                 break;
                 obj_tlen-=16;
                 obj_tptr+=16;
                 break;


@@ -1489,10 +1486,10 @@ _U_
             switch(rsvp_obj_ctype) {
             case RSVP_CTYPE_TUNNEL_IPV4:
                 while(obj_tlen >= 8) {
             switch(rsvp_obj_ctype) {
             case RSVP_CTYPE_TUNNEL_IPV4:
                 while(obj_tlen >= 8) {

-                    printf("%s  PLR-ID: %s, Avoid-Node-ID: %s",
+                    ND_PRINT((ndo, "%s  PLR-ID: %s, Avoid-Node-ID: %s",

                            ident,
                            ipaddr_string(obj_tptr),
                            ident,
                            ipaddr_string(obj_tptr),

-                           ipaddr_string(obj_tptr+4));
+                           ipaddr_string(obj_tptr + 4)));

                     obj_tlen-=8;
                     obj_tptr+=8;
                 }
                     obj_tlen-=8;
                     obj_tptr+=8;
                 }


@@ -1506,9 +1503,9 @@ _U_
         case RSVP_OBJ_CLASSTYPE_OLD: /* fall through */
             switch(rsvp_obj_ctype) {
             case RSVP_CTYPE_1:
         case RSVP_OBJ_CLASSTYPE_OLD: /* fall through */
             switch(rsvp_obj_ctype) {
             case RSVP_CTYPE_1:

-                printf("%s  CT: %u",
+                ND_PRINT((ndo, "%s  CT: %u",

                        ident,
                        ident,

-                       EXTRACT_32BITS(obj_tptr)&0x7);
+                       EXTRACT_32BITS(obj_tptr) & 0x7));

                 obj_tlen-=4;
                 obj_tptr+=4;
                 break;
                 obj_tlen-=4;
                 obj_tptr+=4;
                 break;


@@ -1525,27 +1522,27 @@ _U_
                     return-1;
                 error_code=*(obj_tptr+5);
                 error_value=EXTRACT_16BITS(obj_tptr+6);
                     return-1;
                 error_code=*(obj_tptr+5);
                 error_value=EXTRACT_16BITS(obj_tptr+6);

-                printf("%s  Error Node Address: %s, Flags: [0x%02x]%s  Error Code: %s (%u)",
+                ND_PRINT((ndo, "%s  Error Node Address: %s, Flags: [0x%02x]%s  Error Code: %s (%u)",

                        ident,
                        ipaddr_string(obj_tptr),
                        *(obj_tptr+4),
                        ident,
                        tok2str(rsvp_obj_error_code_values,"unknown",error_code),
                        ident,
                        ipaddr_string(obj_tptr),
                        *(obj_tptr+4),
                        ident,
                        tok2str(rsvp_obj_error_code_values,"unknown",error_code),

-                       error_code);
+                       error_code));

                 switch (error_code) {
                 case RSVP_OBJ_ERROR_SPEC_CODE_ROUTING:
                 switch (error_code) {
                 case RSVP_OBJ_ERROR_SPEC_CODE_ROUTING:

-                    printf(", Error Value: %s (%u)",
+                    ND_PRINT((ndo, ", Error Value: %s (%u)",

                            tok2str(rsvp_obj_error_code_routing_values,"unknown",error_value),
                            tok2str(rsvp_obj_error_code_routing_values,"unknown",error_value),

-                           error_value);
+                           error_value));

                     break;
                 case RSVP_OBJ_ERROR_SPEC_CODE_DIFFSERV_TE: /* fall through */
                 case RSVP_OBJ_ERROR_SPEC_CODE_DIFFSERV_TE_OLD:
                     break;
                 case RSVP_OBJ_ERROR_SPEC_CODE_DIFFSERV_TE: /* fall through */
                 case RSVP_OBJ_ERROR_SPEC_CODE_DIFFSERV_TE_OLD:

-                    printf(", Error Value: %s (%u)",
+                    ND_PRINT((ndo, ", Error Value: %s (%u)",

                            tok2str(rsvp_obj_error_code_diffserv_te_values,"unknown",error_value),
                            tok2str(rsvp_obj_error_code_diffserv_te_values,"unknown",error_value),

-                           error_value);
+                           error_value));

                     break;
                 default:
                     break;
                 default:

-                    printf(", Unknown Error Value (%u)", error_value);
+                    ND_PRINT((ndo, ", Unknown Error Value (%u)", error_value));

                     break;
                 }
                 obj_tlen-=8;
                     break;
                 }
                 obj_tlen-=8;


@@ -1558,19 +1555,19 @@ _U_
                     return-1;
                 error_code=*(obj_tptr+17);
                 error_value=EXTRACT_16BITS(obj_tptr+18);
                     return-1;
                 error_code=*(obj_tptr+17);
                 error_value=EXTRACT_16BITS(obj_tptr+18);

-                printf("%s  Error Node Address: %s, Flags: [0x%02x]%s  Error Code: %s (%u)",
+                ND_PRINT((ndo, "%s  Error Node Address: %s, Flags: [0x%02x]%s  Error Code: %s (%u)",

                        ident,
                        ip6addr_string(obj_tptr),
                        *(obj_tptr+16),
                        ident,
                        tok2str(rsvp_obj_error_code_values,"unknown",error_code),
                        ident,
                        ip6addr_string(obj_tptr),
                        *(obj_tptr+16),
                        ident,
                        tok2str(rsvp_obj_error_code_values,"unknown",error_code),

-                       error_code);
+                       error_code));

 
                 switch (error_code) {
                 case RSVP_OBJ_ERROR_SPEC_CODE_ROUTING:
 
                 switch (error_code) {
                 case RSVP_OBJ_ERROR_SPEC_CODE_ROUTING:

-                    printf(", Error Value: %s (%u)",
+                    ND_PRINT((ndo, ", Error Value: %s (%u)",

                            tok2str(rsvp_obj_error_code_routing_values,"unknown",error_value),
                            tok2str(rsvp_obj_error_code_routing_values,"unknown",error_value),

-                          error_value);
+                          error_value));

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


@@ -1590,24 +1587,24 @@ _U_
                 if (obj_tlen < 4)
                     return-1;
                 padbytes = EXTRACT_16BITS(obj_tptr+2);
                 if (obj_tlen < 4)
                     return-1;
                 padbytes = EXTRACT_16BITS(obj_tptr+2);

-                printf("%s  TLV count: %u, padding bytes: %u",
+                ND_PRINT((ndo, "%s  TLV count: %u, padding bytes: %u",

                        ident,
                        EXTRACT_16BITS(obj_tptr),
                        ident,
                        EXTRACT_16BITS(obj_tptr),

-                       padbytes);
+                       padbytes));

                 obj_tlen-=4;
                 obj_tptr+=4;
                 /* loop through as long there is anything longer than the TLV header (2) */
                 while(obj_tlen >= 2 + padbytes) {
                 obj_tlen-=4;
                 obj_tptr+=4;
                 /* loop through as long there is anything longer than the TLV header (2) */
                 while(obj_tlen >= 2 + padbytes) {

-                    printf("%s    %s TLV (0x%02x), length: %u", /* length includes header */
+                    ND_PRINT((ndo, "%s    %s TLV (0x%02x), length: %u", /* length includes header */

                            ident,
                            tok2str(rsvp_obj_prop_tlv_values,"unknown",*obj_tptr),
                            *obj_tptr,
                            ident,
                            tok2str(rsvp_obj_prop_tlv_values,"unknown",*obj_tptr),
                            *obj_tptr,

-                           *(obj_tptr+1));
+                           *(obj_tptr + 1)));

                     if (obj_tlen < *(obj_tptr+1))
                         return-1;
                     if (*(obj_tptr+1) < 2)
                         return -1;
                     if (obj_tlen < *(obj_tptr+1))
                         return-1;
                     if (*(obj_tptr+1) < 2)
                         return -1;

-                    print_unknown_data(gndo,obj_tptr+2,"\n\t\t",*(obj_tptr+1)-2);
+                    print_unknown_data(ndo, obj_tptr + 2, "\n\t\t", *(obj_tptr + 1) - 2);

                     obj_tlen-=*(obj_tptr+1);
                     obj_tptr+=*(obj_tptr+1);
                 }
                     obj_tlen-=*(obj_tptr+1);
                     obj_tptr+=*(obj_tptr+1);
                 }


@@ -1625,18 +1622,18 @@ _U_
             case RSVP_CTYPE_2:
                 if (obj_tlen < 8)
                     return-1;
             case RSVP_CTYPE_2:
                 if (obj_tlen < 8)
                     return-1;

-                printf("%s  Flags [0x%02x], epoch: %u",
+                ND_PRINT((ndo, "%s  Flags [0x%02x], epoch: %u",

                        ident,
                        *obj_tptr,
                        ident,
                        *obj_tptr,

-                       EXTRACT_24BITS(obj_tptr+1));
+                       EXTRACT_24BITS(obj_tptr + 1)));

                 obj_tlen-=4;
                 obj_tptr+=4;
                 /* loop through as long there are no messages left */
                 while(obj_tlen >= 4) {
                 obj_tlen-=4;
                 obj_tptr+=4;
                 /* loop through as long there are no messages left */
                 while(obj_tlen >= 4) {

-                    printf("%s    Message-ID 0x%08x (%u)",
+                    ND_PRINT((ndo, "%s    Message-ID 0x%08x (%u)",

                            ident,
                            EXTRACT_32BITS(obj_tptr),
                            ident,
                            EXTRACT_32BITS(obj_tptr),

-                           EXTRACT_32BITS(obj_tptr));
+                           EXTRACT_32BITS(obj_tptr)));

                     obj_tlen-=4;
                     obj_tptr+=4;
                 }
                     obj_tlen-=4;
                     obj_tptr+=4;
                 }


@@ -1652,7 +1649,7 @@ _U_
                 if (obj_tlen < sizeof(struct rsvp_obj_integrity_t))
                     return-1;
                 obj_ptr.rsvp_obj_integrity = (const struct rsvp_obj_integrity_t *)obj_tptr;
                 if (obj_tlen < sizeof(struct rsvp_obj_integrity_t))
                     return-1;
                 obj_ptr.rsvp_obj_integrity = (const struct rsvp_obj_integrity_t *)obj_tptr;

-                printf("%s  Key-ID 0x%04x%08x, Sequence 0x%08x%08x, Flags [%s]",
+                ND_PRINT((ndo, "%s  Key-ID 0x%04x%08x, Sequence 0x%08x%08x, Flags [%s]",

                        ident,
                        EXTRACT_16BITS(obj_ptr.rsvp_obj_integrity->key_id),
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_integrity->key_id+2),
                        ident,
                        EXTRACT_16BITS(obj_ptr.rsvp_obj_integrity->key_id),
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_integrity->key_id+2),


@@ -1660,13 +1657,13 @@ _U_
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_integrity->sequence+4),
                        bittok2str(rsvp_obj_integrity_flag_values,
                                   "none",
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_integrity->sequence+4),
                        bittok2str(rsvp_obj_integrity_flag_values,
                                   "none",

-                                  obj_ptr.rsvp_obj_integrity->flags));
-                printf("%s  MD5-sum 0x%08x%08x%08x%08x ",
+                                  obj_ptr.rsvp_obj_integrity->flags)));
+                ND_PRINT((ndo, "%s  MD5-sum 0x%08x%08x%08x%08x ",

                        ident,
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_integrity->digest),
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_integrity->digest+4),
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_integrity->digest+8),
                        ident,
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_integrity->digest),
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_integrity->digest+4),
                        EXTRACT_32BITS(obj_ptr.rsvp_obj_integrity->digest+8),

-                       EXTRACT_32BITS(obj_ptr.rsvp_obj_integrity->digest+12));
+                       EXTRACT_32BITS(obj_ptr.rsvp_obj_integrity->digest + 12)));

 
 #ifdef HAVE_LIBCRYPTO
                 sigcheck = signature_verify(pptr, plen, (unsigned char *)obj_ptr.\
 
 #ifdef HAVE_LIBCRYPTO
                 sigcheck = signature_verify(pptr, plen, (unsigned char *)obj_ptr.\


@@ -1674,7 +1671,7 @@ _U_
 #else
                 sigcheck = CANT_CHECK_SIGNATURE;
 #endif
 #else
                 sigcheck = CANT_CHECK_SIGNATURE;
 #endif

-                printf(" (%s)", tok2str(signature_check_values, "Unknown", sigcheck));
+                ND_PRINT((ndo, " (%s)", tok2str(signature_check_values, "Unknown", sigcheck)));

 
                 obj_tlen+=sizeof(struct rsvp_obj_integrity_t);
                 obj_tptr+=sizeof(struct rsvp_obj_integrity_t);
 
                 obj_tlen+=sizeof(struct rsvp_obj_integrity_t);
                 obj_tptr+=sizeof(struct rsvp_obj_integrity_t);


@@ -1689,9 +1686,9 @@ _U_
             case RSVP_CTYPE_1:
                 if (obj_tlen < 4)
                     return-1;
             case RSVP_CTYPE_1:
                 if (obj_tlen < 4)
                     return-1;

-                printf("%s  Flags [%s]", ident,
+                ND_PRINT((ndo, "%s  Flags [%s]", ident,

                        bittok2str(rsvp_obj_admin_status_flag_values, "none",
                        bittok2str(rsvp_obj_admin_status_flag_values, "none",

-                                  EXTRACT_32BITS(obj_tptr)));
+                                  EXTRACT_32BITS(obj_tptr))));

                 obj_tlen-=4;
                 obj_tptr+=4;
                 break;
                 obj_tlen-=4;
                 obj_tptr+=4;
                 break;


@@ -1707,9 +1704,9 @@ _U_
                     return-1;
                 action = (EXTRACT_16BITS(obj_tptr)>>8);
 
                     return-1;
                 action = (EXTRACT_16BITS(obj_tptr)>>8);
 

-                printf("%s  Action: %s (%u), Label type: %u", ident,
+                ND_PRINT((ndo, "%s  Action: %s (%u), Label type: %u", ident,

                        tok2str(rsvp_obj_label_set_action_values, "Unknown", action),
                        tok2str(rsvp_obj_label_set_action_values, "Unknown", action),

-                       action, ((EXTRACT_32BITS(obj_tptr) & 0x7F)));
+                       action, ((EXTRACT_32BITS(obj_tptr) & 0x7F))));

 
                 switch (action) {
                 case LABEL_SET_INCLUSIVE_RANGE:
 
                 switch (action) {
                 case LABEL_SET_INCLUSIVE_RANGE:


@@ -1718,9 +1715,9 @@ _U_
                    /* only a couple of subchannels are expected */
                    if (obj_tlen < 12)
                        return -1;
                    /* only a couple of subchannels are expected */
                    if (obj_tlen < 12)
                        return -1;

-                   printf("%s  Start range: %u, End range: %u", ident,
+                   ND_PRINT((ndo, "%s  Start range: %u, End range: %u", ident,

                            EXTRACT_32BITS(obj_tptr+4),
                            EXTRACT_32BITS(obj_tptr+4),

-                           EXTRACT_32BITS(obj_tptr+8));
+                           EXTRACT_32BITS(obj_tptr + 8)));

                    obj_tlen-=12;
                    obj_tptr+=12;
                     break;
                    obj_tlen-=12;
                    obj_tptr+=12;
                     break;


@@ -1730,8 +1727,8 @@ _U_
                     obj_tptr+=4;
                     subchannel = 1;
                     while(obj_tlen >= 4 ) {
                     obj_tptr+=4;
                     subchannel = 1;
                     while(obj_tlen >= 4 ) {

-                        printf("%s  Subchannel #%u: %u", ident, subchannel,
-                               EXTRACT_32BITS(obj_tptr));
+                        ND_PRINT((ndo, "%s  Subchannel #%u: %u", ident, subchannel,
+                               EXTRACT_32BITS(obj_tptr)));

                         obj_tptr+=4;
                         obj_tlen-=4;
                         subchannel++;
                         obj_tptr+=4;
                         obj_tlen-=4;
                         subchannel++;


@@ -1748,8 +1745,8 @@ _U_
             case RSVP_CTYPE_IPV4:
                 if (obj_tlen < 4)
                     return-1;
             case RSVP_CTYPE_IPV4:
                 if (obj_tlen < 4)
                     return-1;

-                printf("%s  Sub-LSP destination address: %s",
-                       ident, ipaddr_string(obj_tptr));
+                ND_PRINT((ndo, "%s  Sub-LSP destination address: %s",
+                       ident, ipaddr_string(obj_tptr)));

 
                 obj_tlen-=4;
                 obj_tptr+=4;
 
                 obj_tlen-=4;
                 obj_tptr+=4;


@@ -1758,8 +1755,8 @@ _U_
             case RSVP_CTYPE_IPV6:
                 if (obj_tlen < 16)
                     return-1;
             case RSVP_CTYPE_IPV6:
                 if (obj_tlen < 16)
                     return-1;

-                printf("%s  Sub-LSP destination address: %s",
-                       ident, ip6addr_string(obj_tptr));
+                ND_PRINT((ndo, "%s  Sub-LSP destination address: %s",
+                       ident, ip6addr_string(obj_tptr)));

 
                 obj_tlen-=16;
                 obj_tptr+=16;
 
                 obj_tlen-=16;
                 obj_tptr+=16;


@@ -1779,27 +1776,27 @@ _U_
         case RSVP_OBJ_ACCEPT_LABEL_SET:
         case RSVP_OBJ_PROTECTION:
         default:
         case RSVP_OBJ_ACCEPT_LABEL_SET:
         case RSVP_OBJ_PROTECTION:
         default:

-            if (vflag <= 1)
-                print_unknown_data(gndo,obj_tptr,"\n\t    ",obj_tlen); /* FIXME indentation */
+            if (ndo->ndo_vflag <= 1)
+                print_unknown_data(ndo, obj_tptr, "\n\t    ", obj_tlen); /* FIXME indentation */

             break;
         }
         /* do we also want to see a hex dump ? */
             break;
         }
         /* do we also want to see a hex dump ? */

-        if (vflag > 1 || hexdump==TRUE)
-            print_unknown_data(gndo,tptr+sizeof(struct rsvp_object_header),"\n\t    ", /* FIXME indentation */
-                               rsvp_obj_len-sizeof(struct rsvp_object_header));
+        if (ndo->ndo_vflag > 1 || hexdump == TRUE)
+            print_unknown_data(ndo, tptr + sizeof(struct rsvp_object_header), "\n\t    ", /* FIXME indentation */
+                               rsvp_obj_len - sizeof(struct rsvp_object_header));

 
         tptr+=rsvp_obj_len;
         tlen-=rsvp_obj_len;
     }
     return 0;
 trunc:
 
         tptr+=rsvp_obj_len;
         tlen-=rsvp_obj_len;
     }
     return 0;
 trunc:

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

     return -1;
 }
 
     return -1;
 }
 

-

 void
 void

-rsvp_print(register const u_char *pptr, register u_int len) {
+rsvp_print(netdissect_options *ndo,
+           register const u_char *pptr, register u_int len) {

 
     struct rsvp_common_header *rsvp_com_header;
     const u_char *tptr,*subtptr;
 
     struct rsvp_common_header *rsvp_com_header;
     const u_char *tptr,*subtptr;


@@ -1808,23 +1805,23 @@ rsvp_print(register const u_char *pptr, register u_int len) {
     tptr=pptr;
 
     rsvp_com_header = (struct rsvp_common_header *)pptr;
     tptr=pptr;
 
     rsvp_com_header = (struct rsvp_common_header *)pptr;

-    TCHECK(*rsvp_com_header);
+    ND_TCHECK(*rsvp_com_header);

 
     /*
      * Sanity checking of the header.
      */
     if (RSVP_EXTRACT_VERSION(rsvp_com_header->version_flags) != RSVP_VERSION) {
 
     /*
      * Sanity checking of the header.
      */
     if (RSVP_EXTRACT_VERSION(rsvp_com_header->version_flags) != RSVP_VERSION) {

-       printf("ERROR: RSVP version %u packet not supported",
-               RSVP_EXTRACT_VERSION(rsvp_com_header->version_flags));
+       ND_PRINT((ndo, "ERROR: RSVP version %u packet not supported",
+               RSVP_EXTRACT_VERSION(rsvp_com_header->version_flags)));

        return;
     }
 
     /* in non-verbose mode just lets print the basic Message Type*/
        return;
     }
 
     /* in non-verbose mode just lets print the basic Message Type*/

-    if (vflag < 1) {
-        printf("RSVPv%u %s Message, length: %u",
+    if (ndo->ndo_vflag < 1) {
+        ND_PRINT((ndo, "RSVPv%u %s Message, length: %u",

                RSVP_EXTRACT_VERSION(rsvp_com_header->version_flags),
                tok2str(rsvp_msg_type_values, "unknown (%u)",rsvp_com_header->msg_type),
                RSVP_EXTRACT_VERSION(rsvp_com_header->version_flags),
                tok2str(rsvp_msg_type_values, "unknown (%u)",rsvp_com_header->msg_type),

-               len);
+               len));

         return;
     }
 
         return;
     }
 


@@ -1832,14 +1829,14 @@ rsvp_print(register const u_char *pptr, register u_int len) {
 
     plen = tlen = EXTRACT_16BITS(rsvp_com_header->length);
 
 
     plen = tlen = EXTRACT_16BITS(rsvp_com_header->length);
 

-    printf("\n\tRSVPv%u %s Message (%u), Flags: [%s], length: %u, ttl: %u, checksum: 0x%04x",
+    ND_PRINT((ndo, "\n\tRSVPv%u %s Message (%u), Flags: [%s], length: %u, ttl: %u, checksum: 0x%04x",

            RSVP_EXTRACT_VERSION(rsvp_com_header->version_flags),
            tok2str(rsvp_msg_type_values, "unknown, type: %u",rsvp_com_header->msg_type),
            rsvp_com_header->msg_type,
            bittok2str(rsvp_header_flag_values,"none",RSVP_EXTRACT_FLAGS(rsvp_com_header->version_flags)),
            tlen,
            rsvp_com_header->ttl,
            RSVP_EXTRACT_VERSION(rsvp_com_header->version_flags),
            tok2str(rsvp_msg_type_values, "unknown, type: %u",rsvp_com_header->msg_type),
            rsvp_com_header->msg_type,
            bittok2str(rsvp_header_flag_values,"none",RSVP_EXTRACT_FLAGS(rsvp_com_header->version_flags)),
            tlen,
            rsvp_com_header->ttl,

-           EXTRACT_16BITS(rsvp_com_header->checksum));
+           EXTRACT_16BITS(rsvp_com_header->checksum)));

 
     /*
      * Clear checksum prior to signature verification.
 
     /*
      * Clear checksum prior to signature verification.


@@ -1848,8 +1845,8 @@ rsvp_print(register const u_char *pptr, register u_int len) {
     rsvp_com_header->checksum[1] = 0;
 
     if (tlen < sizeof(const struct rsvp_common_header)) {
     rsvp_com_header->checksum[1] = 0;
 
     if (tlen < sizeof(const struct rsvp_common_header)) {

-        printf("ERROR: common header too short %u < %lu", tlen,
-               (unsigned long)sizeof(const struct rsvp_common_header));
+        ND_PRINT((ndo, "ERROR: common header too short %u < %lu", tlen,
+               (unsigned long)sizeof(const struct rsvp_common_header)));

         return;
     }
 
         return;
     }
 


@@ -1862,26 +1859,26 @@ rsvp_print(register const u_char *pptr, register u_int len) {
         while(tlen > 0) {
             subtptr=tptr;
             rsvp_com_header = (struct rsvp_common_header *)subtptr;
         while(tlen > 0) {
             subtptr=tptr;
             rsvp_com_header = (struct rsvp_common_header *)subtptr;

-            TCHECK(*rsvp_com_header);
+            ND_TCHECK(*rsvp_com_header);

 
             /*
              * Sanity checking of the header.
              */
             if (RSVP_EXTRACT_VERSION(rsvp_com_header->version_flags) != RSVP_VERSION) {
 
             /*
              * Sanity checking of the header.
              */
             if (RSVP_EXTRACT_VERSION(rsvp_com_header->version_flags) != RSVP_VERSION) {

-                printf("ERROR: RSVP version %u packet not supported",
-                       RSVP_EXTRACT_VERSION(rsvp_com_header->version_flags));
+                ND_PRINT((ndo, "ERROR: RSVP version %u packet not supported",
+                       RSVP_EXTRACT_VERSION(rsvp_com_header->version_flags)));

                 return;
             }
             subtlen=EXTRACT_16BITS(rsvp_com_header->length);
 
                 return;
             }
             subtlen=EXTRACT_16BITS(rsvp_com_header->length);
 

-            printf("\n\t  RSVPv%u %s Message (%u), Flags: [%s], length: %u, ttl: %u, checksum: 0x%04x",
+            ND_PRINT((ndo, "\n\t  RSVPv%u %s Message (%u), Flags: [%s], length: %u, ttl: %u, checksum: 0x%04x",

                    RSVP_EXTRACT_VERSION(rsvp_com_header->version_flags),
                    tok2str(rsvp_msg_type_values, "unknown, type: %u",rsvp_com_header->msg_type),
                    rsvp_com_header->msg_type,
                    bittok2str(rsvp_header_flag_values,"none",RSVP_EXTRACT_FLAGS(rsvp_com_header->version_flags)),
                    subtlen,
                    rsvp_com_header->ttl,
                    RSVP_EXTRACT_VERSION(rsvp_com_header->version_flags),
                    tok2str(rsvp_msg_type_values, "unknown, type: %u",rsvp_com_header->msg_type),
                    rsvp_com_header->msg_type,
                    bittok2str(rsvp_header_flag_values,"none",RSVP_EXTRACT_FLAGS(rsvp_com_header->version_flags)),
                    subtlen,
                    rsvp_com_header->ttl,

-                   EXTRACT_16BITS(rsvp_com_header->checksum));
+                   EXTRACT_16BITS(rsvp_com_header->checksum)));

 
             /*
              * Clear checksum prior to signature verification.
 
             /*
              * Clear checksum prior to signature verification.


@@ -1890,21 +1887,21 @@ rsvp_print(register const u_char *pptr, register u_int len) {
             rsvp_com_header->checksum[1] = 0;
 
             if (subtlen < sizeof(const struct rsvp_common_header)) {
             rsvp_com_header->checksum[1] = 0;
 
             if (subtlen < sizeof(const struct rsvp_common_header)) {

-                printf("ERROR: common header too short %u < %lu", subtlen,
-                       (unsigned long)sizeof(const struct rsvp_common_header));
+                ND_PRINT((ndo, "ERROR: common header too short %u < %lu", subtlen,
+                       (unsigned long)sizeof(const struct rsvp_common_header)));

                 return;
             }
 
             if (tlen < subtlen) {
                 return;
             }
 
             if (tlen < subtlen) {

-                printf("ERROR: common header too large %u > %u", subtlen,
-                       tlen);
+                ND_PRINT((ndo, "ERROR: common header too large %u > %u", subtlen,
+                       tlen));

                 return;
             }
 
             subtptr+=sizeof(const struct rsvp_common_header);
             subtlen-=sizeof(const struct rsvp_common_header);
 
                 return;
             }
 
             subtptr+=sizeof(const struct rsvp_common_header);
             subtlen-=sizeof(const struct rsvp_common_header);
 

-            if (rsvp_obj_print(pptr, plen, subtptr,"\n\t    ", subtlen) == -1)
+            if (rsvp_obj_print(ndo, pptr, plen, subtptr, "\n\t    ", subtlen) == -1)

                 return;
 
             tptr+=subtlen+sizeof(const struct rsvp_common_header);
                 return;
 
             tptr+=subtlen+sizeof(const struct rsvp_common_header);


@@ -1924,16 +1921,16 @@ rsvp_print(register const u_char *pptr, register u_int len) {
     case RSVP_MSGTYPE_HELLO:
     case RSVP_MSGTYPE_ACK:
     case RSVP_MSGTYPE_SREFRESH:
     case RSVP_MSGTYPE_HELLO:
     case RSVP_MSGTYPE_ACK:
     case RSVP_MSGTYPE_SREFRESH:

-        if (rsvp_obj_print(pptr, plen, tptr,"\n\t  ", tlen) == -1)
+        if (rsvp_obj_print(ndo, pptr, plen, tptr, "\n\t  ", tlen) == -1)

             return;
         break;
 
     default:
             return;
         break;
 
     default:

-        print_unknown_data(gndo,tptr,"\n\t    ",tlen);
+        print_unknown_data(ndo, tptr, "\n\t    ", tlen);

         break;
     }
 
     return;
 trunc:
         break;
     }
 
     return;
 trunc:

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

 }
 }

diff --git a/tcpdump.c b/tcpdump.c
index 9b016f4743fb42cad70b61190efdf2b0cb595c84..be0318538d3da585ff3b80a7e2ebabce43d9f5f5 100644 (file)
--- a/tcpdump.c
+++ b/tcpdump.c
@@ -167,16 +167,6 @@ struct ndo_printer {
 
 
 static const struct printer printers[] = {
 
 
 static const struct printer printers[] = {

-       { ppp_if_print,         DLT_PPP },
-#ifdef DLT_PPP_WITHDIRECTION
-       { ppp_if_print,         DLT_PPP_WITHDIRECTION },
-#endif
-#ifdef DLT_PPP_BSDOS
-       { ppp_bsdos_if_print,   DLT_PPP_BSDOS },
-#endif
-#ifdef DLT_PPP_SERIAL
-       { ppp_hdlc_if_print,    DLT_PPP_SERIAL },
-#endif

        { NULL,                 0 },
 };
 
        { NULL,                 0 },
 };
 


@@ -346,6 +336,16 @@ static const struct ndo_printer ndo_printers[] = {
 #endif
 #ifdef DLT_PRISM_HEADER
        { prism_if_print,       DLT_PRISM_HEADER },
 #endif
 #ifdef DLT_PRISM_HEADER
        { prism_if_print,       DLT_PRISM_HEADER },

+#endif
+       { ppp_if_print,         DLT_PPP },
+#ifdef DLT_PPP_WITHDIRECTION
+       { ppp_if_print,         DLT_PPP_WITHDIRECTION },
+#endif
+#ifdef DLT_PPP_BSDOS
+       { ppp_bsdos_if_print,   DLT_PPP_BSDOS },
+#endif
+#ifdef DLT_PPP_SERIAL
+       { ppp_hdlc_if_print,    DLT_PPP_SERIAL },

 #endif
        { NULL,                 0 },
 };
 #endif
        { NULL,                 0 },
 };