X-Git-Url: https://git.tcpdump.org/tcpdump/blobdiff_plain/dff10c7f70d539c431a1eba9ab5e076d8b0f5c8e..0f328b4aa16b0b47f05a85c440ce1d07719e3cac:/print-decnet.c diff --git a/print-decnet.c b/print-decnet.c index 4c290f9e..9eeff5f8 100644 --- a/print-decnet.c +++ b/print-decnet.c @@ -19,270 +19,752 @@ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ -#ifndef lint -static const char rcsid[] = - "@(#) $Header: /tcpdump/master/tcpdump/print-decnet.c,v 1.28 2000-01-17 06:24:24 itojun Exp $ (LBL)"; -#endif +/* \summary: DECnet printer */ #ifdef HAVE_CONFIG_H #include "config.h" #endif -#include -#include -#include +#include -#if __STDC__ struct mbuf; struct rtentry; -#endif -#include -#ifdef HAVE_LIBDNET +#ifdef HAVE_NETDNET_DNETDB_H #include #endif -#include -#ifdef HAVE_MALLOC_H -#include -#endif #include #include #include -#include -#include "decnet.h" #include "extract.h" -#include "interface.h" +#include "netdissect.h" #include "addrtoname.h" +static const char tstr[] = "[|decnet]"; + +#ifndef _WIN32 +typedef uint8_t byte[1]; /* single byte field */ +#else +/* + * the keyword 'byte' generates conflicts in Windows + */ +typedef unsigned char Byte[1]; /* single byte field */ +#define byte Byte +#endif /* _WIN32 */ +typedef uint8_t word[2]; /* 2 byte field */ +typedef uint8_t longword[4]; /* 4 bytes field */ + +/* + * Definitions for DECNET Phase IV protocol headers + */ +union etheraddress { + uint8_t dne_addr[6]; /* full ethernet address */ + struct { + uint8_t dne_hiord[4]; /* DECnet HIORD prefix */ + uint8_t dne_nodeaddr[2]; /* DECnet node address */ + } dne_remote; +}; + +typedef union etheraddress etheraddr; /* Ethernet address */ + +#define HIORD 0x000400aa /* high 32-bits of address (swapped) */ + +#define AREAMASK 0176000 /* mask for area field */ +#define AREASHIFT 10 /* bit-offset for area field */ +#define NODEMASK 01777 /* mask for node address field */ + +#define DN_MAXADDL 20 /* max size of DECnet address */ +struct dn_naddr { + uint16_t a_len; /* length of address */ + uint8_t a_addr[DN_MAXADDL]; /* address as bytes */ +}; + +/* + * Define long and short header formats. + */ +struct shorthdr + { + byte sh_flags; /* route flags */ + word sh_dst; /* destination node address */ + word sh_src; /* source node address */ + byte sh_visits; /* visit count */ + }; + +struct longhdr + { + byte lg_flags; /* route flags */ + byte lg_darea; /* destination area (reserved) */ + byte lg_dsarea; /* destination subarea (reserved) */ + etheraddr lg_dst; /* destination id */ + byte lg_sarea; /* source area (reserved) */ + byte lg_ssarea; /* source subarea (reserved) */ + etheraddr lg_src; /* source id */ + byte lg_nextl2; /* next level 2 router (reserved) */ + byte lg_visits; /* visit count */ + byte lg_service; /* service class (reserved) */ + byte lg_pt; /* protocol type (reserved) */ + }; + +union routehdr + { + struct shorthdr rh_short; /* short route header */ + struct longhdr rh_long; /* long route header */ + }; + +/* + * Define the values of various fields in the protocol messages. + * + * 1. Data packet formats. + */ +#define RMF_MASK 7 /* mask for message type */ +#define RMF_SHORT 2 /* short message format */ +#define RMF_LONG 6 /* long message format */ +#ifndef RMF_RQR +#define RMF_RQR 010 /* request return to sender */ +#define RMF_RTS 020 /* returning to sender */ +#define RMF_IE 040 /* intra-ethernet packet */ +#endif /* RMR_RQR */ +#define RMF_FVER 0100 /* future version flag */ +#define RMF_PAD 0200 /* pad field */ +#define RMF_PADMASK 0177 /* pad field mask */ + +#define VIS_MASK 077 /* visit field mask */ + +/* + * 2. Control packet formats. + */ +#define RMF_CTLMASK 017 /* mask for message type */ +#define RMF_CTLMSG 01 /* control message indicator */ +#define RMF_INIT 01 /* initialization message */ +#define RMF_VER 03 /* verification message */ +#define RMF_TEST 05 /* hello and test message */ +#define RMF_L1ROUT 07 /* level 1 routing message */ +#define RMF_L2ROUT 011 /* level 2 routing message */ +#define RMF_RHELLO 013 /* router hello message */ +#define RMF_EHELLO 015 /* endnode hello message */ + +#define TI_L2ROUT 01 /* level 2 router */ +#define TI_L1ROUT 02 /* level 1 router */ +#define TI_ENDNODE 03 /* endnode */ +#define TI_VERIF 04 /* verification required */ +#define TI_BLOCK 010 /* blocking requested */ + +#define VE_VERS 2 /* version number (2) */ +#define VE_ECO 0 /* ECO number */ +#define VE_UECO 0 /* user ECO number (0) */ + +#define P3_VERS 1 /* phase III version number (1) */ +#define P3_ECO 3 /* ECO number (3) */ +#define P3_UECO 0 /* user ECO number (0) */ + +#define II_L2ROUT 01 /* level 2 router */ +#define II_L1ROUT 02 /* level 1 router */ +#define II_ENDNODE 03 /* endnode */ +#define II_VERIF 04 /* verification required */ +#define II_NOMCAST 040 /* no multicast traffic accepted */ +#define II_BLOCK 0100 /* blocking requested */ +#define II_TYPEMASK 03 /* mask for node type */ + +#define TESTDATA 0252 /* test data bytes */ +#define TESTLEN 1 /* length of transmitted test data */ + +/* + * Define control message formats. + */ +struct initmsgIII /* phase III initialization message */ + { + byte inIII_flags; /* route flags */ + word inIII_src; /* source node address */ + byte inIII_info; /* routing layer information */ + word inIII_blksize; /* maximum data link block size */ + byte inIII_vers; /* version number */ + byte inIII_eco; /* ECO number */ + byte inIII_ueco; /* user ECO number */ + byte inIII_rsvd; /* reserved image field */ + }; + +struct initmsg /* initialization message */ + { + byte in_flags; /* route flags */ + word in_src; /* source node address */ + byte in_info; /* routing layer information */ + word in_blksize; /* maximum data link block size */ + byte in_vers; /* version number */ + byte in_eco; /* ECO number */ + byte in_ueco; /* user ECO number */ + word in_hello; /* hello timer */ + byte in_rsvd; /* reserved image field */ + }; + +struct verifmsg /* verification message */ + { + byte ve_flags; /* route flags */ + word ve_src; /* source node address */ + byte ve_fcnval; /* function value image field */ + }; + +struct testmsg /* hello and test message */ + { + byte te_flags; /* route flags */ + word te_src; /* source node address */ + byte te_data; /* test data image field */ + }; + +struct l1rout /* level 1 routing message */ + { + byte r1_flags; /* route flags */ + word r1_src; /* source node address */ + byte r1_rsvd; /* reserved field */ + }; + +struct l2rout /* level 2 routing message */ + { + byte r2_flags; /* route flags */ + word r2_src; /* source node address */ + byte r2_rsvd; /* reserved field */ + }; + +struct rhellomsg /* router hello message */ + { + byte rh_flags; /* route flags */ + byte rh_vers; /* version number */ + byte rh_eco; /* ECO number */ + byte rh_ueco; /* user ECO number */ + etheraddr rh_src; /* source id */ + byte rh_info; /* routing layer information */ + word rh_blksize; /* maximum data link block size */ + byte rh_priority; /* router's priority */ + byte rh_area; /* reserved */ + word rh_hello; /* hello timer */ + byte rh_mpd; /* reserved */ + }; + +struct ehellomsg /* endnode hello message */ + { + byte eh_flags; /* route flags */ + byte eh_vers; /* version number */ + byte eh_eco; /* ECO number */ + byte eh_ueco; /* user ECO number */ + etheraddr eh_src; /* source id */ + byte eh_info; /* routing layer information */ + word eh_blksize; /* maximum data link block size */ + byte eh_area; /* area (reserved) */ + byte eh_seed[8]; /* verification seed */ + etheraddr eh_router; /* designated router */ + word eh_hello; /* hello timer */ + byte eh_mpd; /* (reserved) */ + byte eh_data; /* test data image field */ + }; + +union controlmsg + { + struct initmsg cm_init; /* initialization message */ + struct verifmsg cm_ver; /* verification message */ + struct testmsg cm_test; /* hello and test message */ + struct l1rout cm_l1rou; /* level 1 routing message */ + struct l2rout cm_l2rout; /* level 2 routing message */ + struct rhellomsg cm_rhello; /* router hello message */ + struct ehellomsg cm_ehello; /* endnode hello message */ + }; + +/* Macros for decoding routing-info fields */ +#define RI_COST(x) ((x)&0777) +#define RI_HOPS(x) (((x)>>10)&037) + +/* + * NSP protocol fields and values. + */ + +#define NSP_TYPEMASK 014 /* mask to isolate type code */ +#define NSP_SUBMASK 0160 /* mask to isolate subtype code */ +#define NSP_SUBSHFT 4 /* shift to move subtype code */ + +#define MFT_DATA 0 /* data message */ +#define MFT_ACK 04 /* acknowledgement message */ +#define MFT_CTL 010 /* control message */ + +#define MFS_ILS 020 /* data or I/LS indicator */ +#define MFS_BOM 040 /* beginning of message (data) */ +#define MFS_MOM 0 /* middle of message (data) */ +#define MFS_EOM 0100 /* end of message (data) */ +#define MFS_INT 040 /* interrupt message */ + +#define MFS_DACK 0 /* data acknowledgement */ +#define MFS_IACK 020 /* I/LS acknowledgement */ +#define MFS_CACK 040 /* connect acknowledgement */ + +#define MFS_NOP 0 /* no operation */ +#define MFS_CI 020 /* connect initiate */ +#define MFS_CC 040 /* connect confirm */ +#define MFS_DI 060 /* disconnect initiate */ +#define MFS_DC 0100 /* disconnect confirm */ +#define MFS_RCI 0140 /* retransmitted connect initiate */ + +#define SGQ_ACK 0100000 /* ack */ +#define SGQ_NAK 0110000 /* negative ack */ +#define SGQ_OACK 0120000 /* other channel ack */ +#define SGQ_ONAK 0130000 /* other channel negative ack */ +#define SGQ_MASK 07777 /* mask to isolate seq # */ +#define SGQ_OTHER 020000 /* other channel qualifier */ +#define SGQ_DELAY 010000 /* ack delay flag */ + +#define SGQ_EOM 0100000 /* pseudo flag for end-of-message */ + +#define LSM_MASK 03 /* mask for modifier field */ +#define LSM_NOCHANGE 0 /* no change */ +#define LSM_DONOTSEND 1 /* do not send data */ +#define LSM_SEND 2 /* send data */ + +#define LSI_MASK 014 /* mask for interpretation field */ +#define LSI_DATA 0 /* data segment or message count */ +#define LSI_INTR 4 /* interrupt request count */ +#define LSI_INTM 0377 /* funny marker for int. message */ + +#define COS_MASK 014 /* mask for flow control field */ +#define COS_NONE 0 /* no flow control */ +#define COS_SEGMENT 04 /* segment flow control */ +#define COS_MESSAGE 010 /* message flow control */ +#define COS_DEFAULT 1 /* default value for field */ + +#define COI_MASK 3 /* mask for version field */ +#define COI_32 0 /* version 3.2 */ +#define COI_31 1 /* version 3.1 */ +#define COI_40 2 /* version 4.0 */ +#define COI_41 3 /* version 4.1 */ + +#define MNU_MASK 140 /* mask for session control version */ +#define MNU_10 000 /* session V1.0 */ +#define MNU_20 040 /* session V2.0 */ +#define MNU_ACCESS 1 /* access control present */ +#define MNU_USRDATA 2 /* user data field present */ +#define MNU_INVKPROXY 4 /* invoke proxy field present */ +#define MNU_UICPROXY 8 /* use uic-based proxy */ + +#define DC_NORESOURCES 1 /* no resource reason code */ +#define DC_NOLINK 41 /* no link terminate reason code */ +#define DC_COMPLETE 42 /* disconnect complete reason code */ + +#define DI_NOERROR 0 /* user disconnect */ +#define DI_SHUT 3 /* node is shutting down */ +#define DI_NOUSER 4 /* destination end user does not exist */ +#define DI_INVDEST 5 /* invalid end user destination */ +#define DI_REMRESRC 6 /* insufficient remote resources */ +#define DI_TPA 8 /* third party abort */ +#define DI_PROTOCOL 7 /* protocol error discovered */ +#define DI_ABORT 9 /* user abort */ +#define DI_LOCALRESRC 32 /* insufficient local resources */ +#define DI_REMUSERRESRC 33 /* insufficient remote user resources */ +#define DI_BADACCESS 34 /* bad access control information */ +#define DI_BADACCNT 36 /* bad ACCOUNT information */ +#define DI_CONNECTABORT 38 /* connect request cancelled */ +#define DI_TIMEDOUT 38 /* remote node or user crashed */ +#define DI_UNREACHABLE 39 /* local timers expired due to ... */ +#define DI_BADIMAGE 43 /* bad image data in connect */ +#define DI_SERVMISMATCH 54 /* cryptographic service mismatch */ + +#define UC_OBJREJECT 0 /* object rejected connect */ +#define UC_USERDISCONNECT 0 /* user disconnect */ +#define UC_RESOURCES 1 /* insufficient resources (local or remote) */ +#define UC_NOSUCHNODE 2 /* unrecognized node name */ +#define UC_REMOTESHUT 3 /* remote node shutting down */ +#define UC_NOSUCHOBJ 4 /* unrecognized object */ +#define UC_INVOBJFORMAT 5 /* invalid object name format */ +#define UC_OBJTOOBUSY 6 /* object too busy */ +#define UC_NETWORKABORT 8 /* network abort */ +#define UC_USERABORT 9 /* user abort */ +#define UC_INVNODEFORMAT 10 /* invalid node name format */ +#define UC_LOCALSHUT 11 /* local node shutting down */ +#define UC_ACCESSREJECT 34 /* invalid access control information */ +#define UC_NORESPONSE 38 /* no response from object */ +#define UC_UNREACHABLE 39 /* node unreachable */ + +/* + * NSP message formats. + */ +struct nsphdr /* general nsp header */ + { + byte nh_flags; /* message flags */ + word nh_dst; /* destination link address */ + word nh_src; /* source link address */ + }; + +struct seghdr /* data segment header */ + { + byte sh_flags; /* message flags */ + word sh_dst; /* destination link address */ + word sh_src; /* source link address */ + word sh_seq[3]; /* sequence numbers */ + }; + +struct minseghdr /* minimum data segment header */ + { + byte ms_flags; /* message flags */ + word ms_dst; /* destination link address */ + word ms_src; /* source link address */ + word ms_seq; /* sequence number */ + }; + +struct lsmsg /* link service message (after hdr) */ + { + byte ls_lsflags; /* link service flags */ + byte ls_fcval; /* flow control value */ + }; + +struct ackmsg /* acknowledgement message */ + { + byte ak_flags; /* message flags */ + word ak_dst; /* destination link address */ + word ak_src; /* source link address */ + word ak_acknum[2]; /* acknowledgement numbers */ + }; + +struct minackmsg /* minimum acknowledgement message */ + { + byte mk_flags; /* message flags */ + word mk_dst; /* destination link address */ + word mk_src; /* source link address */ + word mk_acknum; /* acknowledgement number */ + }; + +struct ciackmsg /* connect acknowledgement message */ + { + byte ck_flags; /* message flags */ + word ck_dst; /* destination link address */ + }; + +struct cimsg /* connect initiate message */ + { + byte ci_flags; /* message flags */ + word ci_dst; /* destination link address (0) */ + word ci_src; /* source link address */ + byte ci_services; /* requested services */ + byte ci_info; /* information */ + word ci_segsize; /* maximum segment size */ + }; + +struct ccmsg /* connect confirm message */ + { + byte cc_flags; /* message flags */ + word cc_dst; /* destination link address */ + word cc_src; /* source link address */ + byte cc_services; /* requested services */ + byte cc_info; /* information */ + word cc_segsize; /* maximum segment size */ + byte cc_optlen; /* optional data length */ + }; + +struct cnmsg /* generic connect message */ + { + byte cn_flags; /* message flags */ + word cn_dst; /* destination link address */ + word cn_src; /* source link address */ + byte cn_services; /* requested services */ + byte cn_info; /* information */ + word cn_segsize; /* maximum segment size */ + }; + +struct dimsg /* disconnect initiate message */ + { + byte di_flags; /* message flags */ + word di_dst; /* destination link address */ + word di_src; /* source link address */ + word di_reason; /* reason code */ + byte di_optlen; /* optional data length */ + }; + +struct dcmsg /* disconnect confirm message */ + { + byte dc_flags; /* message flags */ + word dc_dst; /* destination link address */ + word dc_src; /* source link address */ + word dc_reason; /* reason code */ + }; + /* Forwards */ -static void print_decnet_ctlmsg(const union routehdr *, u_int); -static void print_t_info(int); -static void print_l1_routes(const char *, u_int); -static void print_l2_routes(const char *, u_int); -static void print_i_info(int); -static void print_elist(const char *, u_int); -static void print_nsp(const u_char *, u_int); -static void print_reason(int); -#ifdef PRINT_NSPDATA -static void pdata(u_char *, int); -#endif +static int print_decnet_ctlmsg(netdissect_options *, const union routehdr *, u_int, u_int); +static void print_t_info(netdissect_options *, int); +static int print_l1_routes(netdissect_options *, const char *, u_int); +static int print_l2_routes(netdissect_options *, const char *, u_int); +static void print_i_info(netdissect_options *, int); +static int print_elist(const char *, u_int); +static int print_nsp(netdissect_options *, const u_char *, u_int); +static void print_reason(netdissect_options *, int); -#ifdef HAVE_LIBDNET +#ifndef HAVE_NETDNET_DNETDB_H_DNET_HTOA extern char *dnet_htoa(struct dn_naddr *); #endif void -decnet_print(register const u_char *ap, register u_int length, - register u_int caplen) +decnet_print(netdissect_options *ndo, + register const u_char *ap, register u_int length, + register u_int caplen) { - static union routehdr rhcopy; - register union routehdr *rhp = &rhcopy; + register const union routehdr *rhp; register int mflags; int dst, src, hops; - u_int rhlen, nsplen, pktlen; + u_int nsplen, pktlen; const u_char *nspp; if (length < sizeof(struct shorthdr)) { - (void)printf("[|decnet]"); + ND_PRINT((ndo, "%s", tstr)); return; } - pktlen = EXTRACT_LE_16BITS(ap); - - rhlen = min(length, caplen); - rhlen = min(rhlen, sizeof(*rhp)); - memcpy((char *)rhp, (char *)&(ap[sizeof(short)]), rhlen); + ND_TCHECK2(*ap, sizeof(short)); + pktlen = EXTRACT_LE_U_2(ap); + if (pktlen < sizeof(struct shorthdr)) { + ND_PRINT((ndo, "%s", tstr)); + return; + } + if (pktlen > length) { + ND_PRINT((ndo, "%s", tstr)); + return; + } + length = pktlen; - mflags = EXTRACT_LE_8BITS(rhp->rh_short.sh_flags); + rhp = (const union routehdr *)(ap + sizeof(short)); + ND_TCHECK(rhp->rh_short.sh_flags); + mflags = EXTRACT_U_1(rhp->rh_short.sh_flags); if (mflags & RMF_PAD) { /* pad bytes of some sort in front of message */ u_int padlen = mflags & RMF_PADMASK; - if (vflag) - (void) printf("[pad:%d] ", padlen); + if (ndo->ndo_vflag) + ND_PRINT((ndo, "[pad:%d] ", padlen)); + if (length < padlen + 2) { + ND_PRINT((ndo, "%s", tstr)); + return; + } + ND_TCHECK2(ap[sizeof(short)], padlen); ap += padlen; length -= padlen; caplen -= padlen; - rhlen = min(length, caplen); - rhlen = min(rhlen, sizeof(*rhp)); - memcpy((char *)rhp, (char *)&(ap[sizeof(short)]), rhlen); - mflags = EXTRACT_LE_8BITS(rhp->rh_short.sh_flags); + rhp = (const union routehdr *)(ap + sizeof(short)); + ND_TCHECK(rhp->rh_short.sh_flags); + mflags = EXTRACT_U_1(rhp->rh_short.sh_flags); } if (mflags & RMF_FVER) { - (void) printf("future-version-decnet"); - default_print(ap, length); + ND_PRINT((ndo, "future-version-decnet")); + ND_DEFAULTPRINT(ap, min(length, caplen)); return; } /* is it a control message? */ if (mflags & RMF_CTLMSG) { - print_decnet_ctlmsg(rhp, min(length, caplen)); + if (!print_decnet_ctlmsg(ndo, rhp, length, caplen)) + goto trunc; return; } switch (mflags & RMF_MASK) { case RMF_LONG: + if (length < sizeof(struct longhdr)) { + ND_PRINT((ndo, "%s", tstr)); + return; + } + ND_TCHECK(rhp->rh_long); dst = - EXTRACT_LE_16BITS(rhp->rh_long.lg_dst.dne_remote.dne_nodeaddr); + EXTRACT_LE_U_2(rhp->rh_long.lg_dst.dne_remote.dne_nodeaddr); src = - EXTRACT_LE_16BITS(rhp->rh_long.lg_src.dne_remote.dne_nodeaddr); - hops = EXTRACT_LE_8BITS(rhp->rh_long.lg_visits); - nspp = &(ap[sizeof(short) + sizeof(struct longhdr)]); - nsplen = min((length - sizeof(struct longhdr)), - (caplen - sizeof(struct longhdr))); + EXTRACT_LE_U_2(rhp->rh_long.lg_src.dne_remote.dne_nodeaddr); + hops = EXTRACT_U_1(rhp->rh_long.lg_visits); + nspp = ap + sizeof(short) + sizeof(struct longhdr); + nsplen = length - sizeof(struct longhdr); break; case RMF_SHORT: - dst = EXTRACT_LE_16BITS(rhp->rh_short.sh_dst); - src = EXTRACT_LE_16BITS(rhp->rh_short.sh_src); - hops = (EXTRACT_LE_8BITS(rhp->rh_short.sh_visits) & VIS_MASK)+1; - nspp = &(ap[sizeof(short) + sizeof(struct shorthdr)]); - nsplen = min((length - sizeof(struct shorthdr)), - (caplen - sizeof(struct shorthdr))); + ND_TCHECK(rhp->rh_short); + dst = EXTRACT_LE_U_2(rhp->rh_short.sh_dst); + src = EXTRACT_LE_U_2(rhp->rh_short.sh_src); + hops = (EXTRACT_U_1(rhp->rh_short.sh_visits) & VIS_MASK)+1; + nspp = ap + sizeof(short) + sizeof(struct shorthdr); + nsplen = length - sizeof(struct shorthdr); break; default: - (void) printf("unknown message flags under mask"); - default_print((u_char *)ap, length); + ND_PRINT((ndo, "unknown message flags under mask")); + ND_DEFAULTPRINT((const u_char *)ap, min(length, caplen)); return; } - (void)printf("%s > %s %d ", - dnaddr_string(src), dnaddr_string(dst), pktlen); - if (vflag) { + ND_PRINT((ndo, "%s > %s %d ", + dnaddr_string(ndo, src), dnaddr_string(ndo, dst), pktlen)); + if (ndo->ndo_vflag) { if (mflags & RMF_RQR) - (void)printf("RQR "); + ND_PRINT((ndo, "RQR ")); if (mflags & RMF_RTS) - (void)printf("RTS "); + ND_PRINT((ndo, "RTS ")); if (mflags & RMF_IE) - (void)printf("IE "); - (void)printf("%d hops ", hops); + ND_PRINT((ndo, "IE ")); + ND_PRINT((ndo, "%d hops ", hops)); } - print_nsp(nspp, nsplen); + if (!print_nsp(ndo, nspp, nsplen)) + goto trunc; + return; + +trunc: + ND_PRINT((ndo, "%s", tstr)); + return; } -static void -print_decnet_ctlmsg(register const union routehdr *rhp, u_int length) +static int +print_decnet_ctlmsg(netdissect_options *ndo, + register const union routehdr *rhp, u_int length, + u_int caplen) { - int mflags = EXTRACT_LE_8BITS(rhp->rh_short.sh_flags); - register union controlmsg *cmp = (union controlmsg *)rhp; + /* Our caller has already checked for mflags */ + int mflags = EXTRACT_U_1(rhp->rh_short.sh_flags); + register const union controlmsg *cmp = (const union controlmsg *)rhp; int src, dst, info, blksize, eco, ueco, hello, other, vers; etheraddr srcea, rtea; int priority; - char *rhpx = (char *)rhp; + const char *rhpx = (const char *)rhp; + int ret; switch (mflags & RMF_CTLMASK) { case RMF_INIT: - (void)printf("init "); - src = EXTRACT_LE_16BITS(cmp->cm_init.in_src); - info = EXTRACT_LE_8BITS(cmp->cm_init.in_info); - blksize = EXTRACT_LE_16BITS(cmp->cm_init.in_blksize); - vers = EXTRACT_LE_8BITS(cmp->cm_init.in_vers); - eco = EXTRACT_LE_8BITS(cmp->cm_init.in_eco); - ueco = EXTRACT_LE_8BITS(cmp->cm_init.in_ueco); - hello = EXTRACT_LE_16BITS(cmp->cm_init.in_hello); - print_t_info(info); - (void)printf( + ND_PRINT((ndo, "init ")); + if (length < sizeof(struct initmsg)) + goto trunc; + ND_TCHECK(cmp->cm_init); + src = EXTRACT_LE_U_2(cmp->cm_init.in_src); + info = EXTRACT_U_1(cmp->cm_init.in_info); + blksize = EXTRACT_LE_U_2(cmp->cm_init.in_blksize); + vers = EXTRACT_U_1(cmp->cm_init.in_vers); + eco = EXTRACT_U_1(cmp->cm_init.in_eco); + ueco = EXTRACT_U_1(cmp->cm_init.in_ueco); + hello = EXTRACT_LE_U_2(cmp->cm_init.in_hello); + print_t_info(ndo, info); + ND_PRINT((ndo, "src %sblksize %d vers %d eco %d ueco %d hello %d", - dnaddr_string(src), blksize, vers, eco, ueco, - hello); + dnaddr_string(ndo, src), blksize, vers, eco, ueco, + hello)); + ret = 1; break; case RMF_VER: - (void)printf("verification "); - src = EXTRACT_LE_16BITS(cmp->cm_ver.ve_src); - other = EXTRACT_LE_8BITS(cmp->cm_ver.ve_fcnval); - (void)printf("src %s fcnval %o", dnaddr_string(src), other); + ND_PRINT((ndo, "verification ")); + if (length < sizeof(struct verifmsg)) + goto trunc; + ND_TCHECK(cmp->cm_ver); + src = EXTRACT_LE_U_2(cmp->cm_ver.ve_src); + other = EXTRACT_U_1(cmp->cm_ver.ve_fcnval); + ND_PRINT((ndo, "src %s fcnval %o", dnaddr_string(ndo, src), other)); + ret = 1; break; case RMF_TEST: - (void)printf("test "); - src = EXTRACT_LE_16BITS(cmp->cm_test.te_src); - other = EXTRACT_LE_8BITS(cmp->cm_test.te_data); - (void)printf("src %s data %o", dnaddr_string(src), other); + ND_PRINT((ndo, "test ")); + if (length < sizeof(struct testmsg)) + goto trunc; + ND_TCHECK(cmp->cm_test); + src = EXTRACT_LE_U_2(cmp->cm_test.te_src); + other = EXTRACT_U_1(cmp->cm_test.te_data); + ND_PRINT((ndo, "src %s data %o", dnaddr_string(ndo, src), other)); + ret = 1; break; case RMF_L1ROUT: - (void)printf("lev-1-routing "); - src = EXTRACT_LE_16BITS(cmp->cm_l1rou.r1_src); - (void)printf("src %s ", dnaddr_string(src)); - print_l1_routes(&(rhpx[sizeof(struct l1rout)]), + ND_PRINT((ndo, "lev-1-routing ")); + if (length < sizeof(struct l1rout)) + goto trunc; + ND_TCHECK(cmp->cm_l1rou); + src = EXTRACT_LE_U_2(cmp->cm_l1rou.r1_src); + ND_PRINT((ndo, "src %s ", dnaddr_string(ndo, src))); + ret = print_l1_routes(ndo, &(rhpx[sizeof(struct l1rout)]), length - sizeof(struct l1rout)); break; case RMF_L2ROUT: - (void)printf("lev-2-routing "); - src = EXTRACT_LE_16BITS(cmp->cm_l2rout.r2_src); - (void)printf("src %s ", dnaddr_string(src)); - print_l2_routes(&(rhpx[sizeof(struct l2rout)]), + ND_PRINT((ndo, "lev-2-routing ")); + if (length < sizeof(struct l2rout)) + goto trunc; + ND_TCHECK(cmp->cm_l2rout); + src = EXTRACT_LE_U_2(cmp->cm_l2rout.r2_src); + ND_PRINT((ndo, "src %s ", dnaddr_string(ndo, src))); + ret = print_l2_routes(ndo, &(rhpx[sizeof(struct l2rout)]), length - sizeof(struct l2rout)); break; case RMF_RHELLO: - (void)printf("router-hello "); - vers = EXTRACT_LE_8BITS(cmp->cm_rhello.rh_vers); - eco = EXTRACT_LE_8BITS(cmp->cm_rhello.rh_eco); - ueco = EXTRACT_LE_8BITS(cmp->cm_rhello.rh_ueco); - memcpy((char *)&srcea, (char *)&(cmp->cm_rhello.rh_src), + ND_PRINT((ndo, "router-hello ")); + if (length < sizeof(struct rhellomsg)) + goto trunc; + ND_TCHECK(cmp->cm_rhello); + vers = EXTRACT_U_1(cmp->cm_rhello.rh_vers); + eco = EXTRACT_U_1(cmp->cm_rhello.rh_eco); + ueco = EXTRACT_U_1(cmp->cm_rhello.rh_ueco); + memcpy((char *)&srcea, (const char *)&(cmp->cm_rhello.rh_src), sizeof(srcea)); - src = EXTRACT_LE_16BITS(srcea.dne_remote.dne_nodeaddr); - info = EXTRACT_LE_8BITS(cmp->cm_rhello.rh_info); - blksize = EXTRACT_LE_16BITS(cmp->cm_rhello.rh_blksize); - priority = EXTRACT_LE_8BITS(cmp->cm_rhello.rh_priority); - hello = EXTRACT_LE_16BITS(cmp->cm_rhello.rh_hello); - print_i_info(info); - (void)printf( + src = EXTRACT_LE_U_2(srcea.dne_remote.dne_nodeaddr); + info = EXTRACT_U_1(cmp->cm_rhello.rh_info); + blksize = EXTRACT_LE_U_2(cmp->cm_rhello.rh_blksize); + priority = EXTRACT_U_1(cmp->cm_rhello.rh_priority); + hello = EXTRACT_LE_U_2(cmp->cm_rhello.rh_hello); + print_i_info(ndo, info); + ND_PRINT((ndo, "vers %d eco %d ueco %d src %s blksize %d pri %d hello %d", - vers, eco, ueco, dnaddr_string(src), - blksize, priority, hello); - print_elist(&(rhpx[sizeof(struct rhellomsg)]), + vers, eco, ueco, dnaddr_string(ndo, src), + blksize, priority, hello)); + ret = print_elist(&(rhpx[sizeof(struct rhellomsg)]), length - sizeof(struct rhellomsg)); break; case RMF_EHELLO: - (void)printf("endnode-hello "); - vers = EXTRACT_LE_8BITS(cmp->cm_ehello.eh_vers); - eco = EXTRACT_LE_8BITS(cmp->cm_ehello.eh_eco); - ueco = EXTRACT_LE_8BITS(cmp->cm_ehello.eh_ueco); - memcpy((char *)&srcea, (char *)&(cmp->cm_ehello.eh_src), + ND_PRINT((ndo, "endnode-hello ")); + if (length < sizeof(struct ehellomsg)) + goto trunc; + ND_TCHECK(cmp->cm_ehello); + vers = EXTRACT_U_1(cmp->cm_ehello.eh_vers); + eco = EXTRACT_U_1(cmp->cm_ehello.eh_eco); + ueco = EXTRACT_U_1(cmp->cm_ehello.eh_ueco); + memcpy((char *)&srcea, (const char *)&(cmp->cm_ehello.eh_src), sizeof(srcea)); - src = EXTRACT_LE_16BITS(srcea.dne_remote.dne_nodeaddr); - info = EXTRACT_LE_8BITS(cmp->cm_ehello.eh_info); - blksize = EXTRACT_LE_16BITS(cmp->cm_ehello.eh_blksize); + src = EXTRACT_LE_U_2(srcea.dne_remote.dne_nodeaddr); + info = EXTRACT_U_1(cmp->cm_ehello.eh_info); + blksize = EXTRACT_LE_U_2(cmp->cm_ehello.eh_blksize); /*seed*/ - memcpy((char *)&rtea, (char *)&(cmp->cm_ehello.eh_router), + memcpy((char *)&rtea, (const char *)&(cmp->cm_ehello.eh_router), sizeof(rtea)); - dst = EXTRACT_LE_16BITS(rtea.dne_remote.dne_nodeaddr); - hello = EXTRACT_LE_16BITS(cmp->cm_ehello.eh_hello); - other = EXTRACT_LE_8BITS(cmp->cm_ehello.eh_data); - print_i_info(info); - (void)printf( + dst = EXTRACT_LE_U_2(rtea.dne_remote.dne_nodeaddr); + hello = EXTRACT_LE_U_2(cmp->cm_ehello.eh_hello); + other = EXTRACT_U_1(cmp->cm_ehello.eh_data); + print_i_info(ndo, info); + ND_PRINT((ndo, "vers %d eco %d ueco %d src %s blksize %d rtr %s hello %d data %o", - vers, eco, ueco, dnaddr_string(src), - blksize, dnaddr_string(dst), hello, other); + vers, eco, ueco, dnaddr_string(ndo, src), + blksize, dnaddr_string(ndo, dst), hello, other)); + ret = 1; break; default: - (void)printf("unknown control message"); - default_print((u_char *)rhp, length); + ND_PRINT((ndo, "unknown control message")); + ND_DEFAULTPRINT((const u_char *)rhp, min(length, caplen)); + ret = 1; break; } + return (ret); + +trunc: + return (0); } static void -print_t_info(int info) +print_t_info(netdissect_options *ndo, + int info) { int ntype = info & 3; switch (ntype) { - case 0: (void)printf("reserved-ntype? "); break; - case TI_L2ROUT: (void)printf("l2rout "); break; - case TI_L1ROUT: (void)printf("l1rout "); break; - case TI_ENDNODE: (void)printf("endnode "); break; + case 0: ND_PRINT((ndo, "reserved-ntype? ")); break; + case TI_L2ROUT: ND_PRINT((ndo, "l2rout ")); break; + case TI_L1ROUT: ND_PRINT((ndo, "l1rout ")); break; + case TI_ENDNODE: ND_PRINT((ndo, "endnode ")); break; } if (info & TI_VERIF) - (void)printf("verif "); + ND_PRINT((ndo, "verif ")); if (info & TI_BLOCK) - (void)printf("blo "); + ND_PRINT((ndo, "blo ")); } -static void -print_l1_routes(const char *rp, u_int len) +static int +print_l1_routes(netdissect_options *ndo, + const char *rp, u_int len) { int count; int id; @@ -290,24 +772,30 @@ print_l1_routes(const char *rp, u_int len) /* The last short is a checksum */ while (len > (3 * sizeof(short))) { - count = EXTRACT_LE_16BITS(rp); + ND_TCHECK2(*rp, 3 * sizeof(short)); + count = EXTRACT_LE_U_2(rp); if (count > 1024) - return; /* seems to be bogus from here on */ + return (1); /* seems to be bogus from here on */ rp += sizeof(short); len -= sizeof(short); - id = EXTRACT_LE_16BITS(rp); + id = EXTRACT_LE_U_2(rp); rp += sizeof(short); len -= sizeof(short); - info = EXTRACT_LE_16BITS(rp); + info = EXTRACT_LE_U_2(rp); rp += sizeof(short); len -= sizeof(short); - (void)printf("{ids %d-%d cost %d hops %d} ", id, id + count, - RI_COST(info), RI_HOPS(info)); + ND_PRINT((ndo, "{ids %d-%d cost %d hops %d} ", id, id + count, + RI_COST(info), RI_HOPS(info))); } + return (1); + +trunc: + return (0); } -static void -print_l2_routes(const char *rp, u_int len) +static int +print_l2_routes(netdissect_options *ndo, + const char *rp, u_int len) { int count; int area; @@ -315,55 +803,66 @@ print_l2_routes(const char *rp, u_int len) /* The last short is a checksum */ while (len > (3 * sizeof(short))) { - count = EXTRACT_LE_16BITS(rp); + ND_TCHECK2(*rp, 3 * sizeof(short)); + count = EXTRACT_LE_U_2(rp); if (count > 1024) - return; /* seems to be bogus from here on */ + return (1); /* seems to be bogus from here on */ rp += sizeof(short); len -= sizeof(short); - area = EXTRACT_LE_16BITS(rp); + area = EXTRACT_LE_U_2(rp); rp += sizeof(short); len -= sizeof(short); - info = EXTRACT_LE_16BITS(rp); + info = EXTRACT_LE_U_2(rp); rp += sizeof(short); len -= sizeof(short); - (void)printf("{areas %d-%d cost %d hops %d} ", area, area + count, - RI_COST(info), RI_HOPS(info)); + ND_PRINT((ndo, "{areas %d-%d cost %d hops %d} ", area, area + count, + RI_COST(info), RI_HOPS(info))); } + return (1); + +trunc: + return (0); } static void -print_i_info(int info) +print_i_info(netdissect_options *ndo, + int info) { int ntype = info & II_TYPEMASK; switch (ntype) { - case 0: (void)printf("reserved-ntype? "); break; - case II_L2ROUT: (void)printf("l2rout "); break; - case II_L1ROUT: (void)printf("l1rout "); break; - case II_ENDNODE: (void)printf("endnode "); break; + case 0: ND_PRINT((ndo, "reserved-ntype? ")); break; + case II_L2ROUT: ND_PRINT((ndo, "l2rout ")); break; + case II_L1ROUT: ND_PRINT((ndo, "l1rout ")); break; + case II_ENDNODE: ND_PRINT((ndo, "endnode ")); break; } if (info & II_VERIF) - (void)printf("verif "); + ND_PRINT((ndo, "verif ")); if (info & II_NOMCAST) - (void)printf("nomcast "); + ND_PRINT((ndo, "nomcast ")); if (info & II_BLOCK) - (void)printf("blo "); + ND_PRINT((ndo, "blo ")); } -static void -print_elist(const char *elp, u_int len) +static int +print_elist(const char *elp _U_, u_int len _U_) { /* Not enough examples available for me to debug this */ + return (1); } -static void -print_nsp(const u_char *nspp, u_int nsplen) +static int +print_nsp(netdissect_options *ndo, + const u_char *nspp, u_int nsplen) { - const struct nsphdr *nsphp = (struct nsphdr *)nspp; + const struct nsphdr *nsphp = (const struct nsphdr *)nspp; int dst, src, flags; - flags = EXTRACT_LE_8BITS(nsphp->nh_flags); - dst = EXTRACT_LE_16BITS(nsphp->nh_dst); - src = EXTRACT_LE_16BITS(nsphp->nh_src); + if (nsplen < sizeof(struct nsphdr)) + goto trunc; + ND_TCHECK(*nsphp); + flags = EXTRACT_U_1(nsphp->nh_flags); + dst = EXTRACT_LE_U_2(nsphp->nh_dst); + src = EXTRACT_LE_U_2(nsphp->nh_src); switch (flags & NSP_TYPEMASK) { case MFT_DATA: @@ -372,182 +871,199 @@ print_nsp(const u_char *nspp, u_int nsplen) case MFS_MOM: case MFS_EOM: case MFS_BOM+MFS_EOM: - printf("data %d>%d ", src, dst); + ND_PRINT((ndo, "data %d>%d ", src, dst)); { - struct seghdr *shp = (struct seghdr *)nspp; + const struct seghdr *shp = (const struct seghdr *)nspp; int ack; -#ifdef PRINT_NSPDATA - u_char *dp; -#endif u_int data_off = sizeof(struct minseghdr); - ack = EXTRACT_LE_16BITS(shp->sh_seq[0]); + if (nsplen < data_off) + goto trunc; + ND_TCHECK(shp->sh_seq[0]); + ack = EXTRACT_LE_U_2(shp->sh_seq[0]); if (ack & SGQ_ACK) { /* acknum field */ if ((ack & SGQ_NAK) == SGQ_NAK) - (void)printf("nak %d ", ack & SGQ_MASK); + ND_PRINT((ndo, "nak %d ", ack & SGQ_MASK)); else - (void)printf("ack %d ", ack & SGQ_MASK); - ack = EXTRACT_LE_16BITS(shp->sh_seq[1]); + ND_PRINT((ndo, "ack %d ", ack & SGQ_MASK)); data_off += sizeof(short); + if (nsplen < data_off) + goto trunc; + ND_TCHECK(shp->sh_seq[1]); + ack = EXTRACT_LE_U_2(shp->sh_seq[1]); if (ack & SGQ_OACK) { /* ackoth field */ if ((ack & SGQ_ONAK) == SGQ_ONAK) - (void)printf("onak %d ", ack & SGQ_MASK); + ND_PRINT((ndo, "onak %d ", ack & SGQ_MASK)); else - (void)printf("oack %d ", ack & SGQ_MASK); - ack = EXTRACT_LE_16BITS(shp->sh_seq[2]); + ND_PRINT((ndo, "oack %d ", ack & SGQ_MASK)); data_off += sizeof(short); + if (nsplen < data_off) + goto trunc; + ND_TCHECK(shp->sh_seq[2]); + ack = EXTRACT_LE_U_2(shp->sh_seq[2]); } } - (void)printf("seg %d ", ack & SGQ_MASK); -#ifdef PRINT_NSPDATA - dp = &(nspp[data_off]); - pdata(dp, 10); -#endif + ND_PRINT((ndo, "seg %d ", ack & SGQ_MASK)); } break; case MFS_ILS+MFS_INT: - printf("intr "); + ND_PRINT((ndo, "intr ")); { - struct seghdr *shp = (struct seghdr *)nspp; + const struct seghdr *shp = (const struct seghdr *)nspp; int ack; -#ifdef PRINT_NSPDATA - u_char *dp; -#endif u_int data_off = sizeof(struct minseghdr); - ack = EXTRACT_LE_16BITS(shp->sh_seq[0]); + if (nsplen < data_off) + goto trunc; + ND_TCHECK(shp->sh_seq[0]); + ack = EXTRACT_LE_U_2(shp->sh_seq[0]); if (ack & SGQ_ACK) { /* acknum field */ if ((ack & SGQ_NAK) == SGQ_NAK) - (void)printf("nak %d ", ack & SGQ_MASK); + ND_PRINT((ndo, "nak %d ", ack & SGQ_MASK)); else - (void)printf("ack %d ", ack & SGQ_MASK); - ack = EXTRACT_LE_16BITS(shp->sh_seq[1]); + ND_PRINT((ndo, "ack %d ", ack & SGQ_MASK)); data_off += sizeof(short); + if (nsplen < data_off) + goto trunc; + ND_TCHECK(shp->sh_seq[1]); + ack = EXTRACT_LE_U_2(shp->sh_seq[1]); if (ack & SGQ_OACK) { /* ackdat field */ if ((ack & SGQ_ONAK) == SGQ_ONAK) - (void)printf("nakdat %d ", ack & SGQ_MASK); + ND_PRINT((ndo, "nakdat %d ", ack & SGQ_MASK)); else - (void)printf("ackdat %d ", ack & SGQ_MASK); - ack = EXTRACT_LE_16BITS(shp->sh_seq[2]); + ND_PRINT((ndo, "ackdat %d ", ack & SGQ_MASK)); data_off += sizeof(short); + if (nsplen < data_off) + goto trunc; + ND_TCHECK(shp->sh_seq[2]); + ack = EXTRACT_LE_U_2(shp->sh_seq[2]); } } - (void)printf("seg %d ", ack & SGQ_MASK); -#ifdef PRINT_NSPDATA - dp = &(nspp[data_off]); - pdata(dp, 10); -#endif + ND_PRINT((ndo, "seg %d ", ack & SGQ_MASK)); } break; case MFS_ILS: - (void)printf("link-service %d>%d ", src, dst); + ND_PRINT((ndo, "link-service %d>%d ", src, dst)); { - struct seghdr *shp = (struct seghdr *)nspp; - struct lsmsg *lsmp = - (struct lsmsg *)&(nspp[sizeof(struct seghdr)]); + const struct seghdr *shp = (const struct seghdr *)nspp; + const struct lsmsg *lsmp = + (const struct lsmsg *)(nspp + sizeof(struct seghdr)); int ack; int lsflags, fcval; - ack = EXTRACT_LE_16BITS(shp->sh_seq[0]); + if (nsplen < sizeof(struct seghdr) + sizeof(struct lsmsg)) + goto trunc; + ND_TCHECK(shp->sh_seq[0]); + ack = EXTRACT_LE_U_2(shp->sh_seq[0]); if (ack & SGQ_ACK) { /* acknum field */ if ((ack & SGQ_NAK) == SGQ_NAK) - (void)printf("nak %d ", ack & SGQ_MASK); + ND_PRINT((ndo, "nak %d ", ack & SGQ_MASK)); else - (void)printf("ack %d ", ack & SGQ_MASK); - ack = EXTRACT_LE_16BITS(shp->sh_seq[1]); + ND_PRINT((ndo, "ack %d ", ack & SGQ_MASK)); + ND_TCHECK(shp->sh_seq[1]); + ack = EXTRACT_LE_U_2(shp->sh_seq[1]); if (ack & SGQ_OACK) { /* ackdat field */ if ((ack & SGQ_ONAK) == SGQ_ONAK) - (void)printf("nakdat %d ", ack & SGQ_MASK); + ND_PRINT((ndo, "nakdat %d ", ack & SGQ_MASK)); else - (void)printf("ackdat %d ", ack & SGQ_MASK); - ack = EXTRACT_LE_16BITS(shp->sh_seq[2]); + ND_PRINT((ndo, "ackdat %d ", ack & SGQ_MASK)); + ND_TCHECK(shp->sh_seq[2]); + ack = EXTRACT_LE_U_2(shp->sh_seq[2]); } } - (void)printf("seg %d ", ack & SGQ_MASK); - lsflags = EXTRACT_LE_8BITS(lsmp->ls_lsflags); - fcval = EXTRACT_LE_8BITS(lsmp->ls_fcval); + ND_PRINT((ndo, "seg %d ", ack & SGQ_MASK)); + ND_TCHECK(*lsmp); + lsflags = EXTRACT_U_1(lsmp->ls_lsflags); + fcval = EXTRACT_U_1(lsmp->ls_fcval); switch (lsflags & LSI_MASK) { case LSI_DATA: - (void)printf("dat seg count %d ", fcval); + ND_PRINT((ndo, "dat seg count %d ", fcval)); switch (lsflags & LSM_MASK) { case LSM_NOCHANGE: break; case LSM_DONOTSEND: - (void)printf("donotsend-data "); + ND_PRINT((ndo, "donotsend-data ")); break; case LSM_SEND: - (void)printf("send-data "); + ND_PRINT((ndo, "send-data ")); break; default: - (void)printf("reserved-fcmod? %x", lsflags); + ND_PRINT((ndo, "reserved-fcmod? %x", lsflags)); break; } break; case LSI_INTR: - (void)printf("intr req count %d ", fcval); + ND_PRINT((ndo, "intr req count %d ", fcval)); break; default: - (void)printf("reserved-fcval-int? %x", lsflags); + ND_PRINT((ndo, "reserved-fcval-int? %x", lsflags)); break; } } break; default: - (void)printf("reserved-subtype? %x %d > %d", flags, src, dst); + ND_PRINT((ndo, "reserved-subtype? %x %d > %d", flags, src, dst)); break; } break; case MFT_ACK: switch (flags & NSP_SUBMASK) { case MFS_DACK: - (void)printf("data-ack %d>%d ", src, dst); + ND_PRINT((ndo, "data-ack %d>%d ", src, dst)); { - struct ackmsg *amp = (struct ackmsg *)nspp; + const struct ackmsg *amp = (const struct ackmsg *)nspp; int ack; - ack = EXTRACT_LE_16BITS(amp->ak_acknum[0]); + if (nsplen < sizeof(struct ackmsg)) + goto trunc; + ND_TCHECK(*amp); + ack = EXTRACT_LE_U_2(amp->ak_acknum[0]); if (ack & SGQ_ACK) { /* acknum field */ if ((ack & SGQ_NAK) == SGQ_NAK) - (void)printf("nak %d ", ack & SGQ_MASK); + ND_PRINT((ndo, "nak %d ", ack & SGQ_MASK)); else - (void)printf("ack %d ", ack & SGQ_MASK); - ack = EXTRACT_LE_16BITS(amp->ak_acknum[1]); + ND_PRINT((ndo, "ack %d ", ack & SGQ_MASK)); + ack = EXTRACT_LE_U_2(amp->ak_acknum[1]); if (ack & SGQ_OACK) { /* ackoth field */ if ((ack & SGQ_ONAK) == SGQ_ONAK) - (void)printf("onak %d ", ack & SGQ_MASK); + ND_PRINT((ndo, "onak %d ", ack & SGQ_MASK)); else - (void)printf("oack %d ", ack & SGQ_MASK); + ND_PRINT((ndo, "oack %d ", ack & SGQ_MASK)); } } } break; case MFS_IACK: - (void)printf("ils-ack %d>%d ", src, dst); + ND_PRINT((ndo, "ils-ack %d>%d ", src, dst)); { - struct ackmsg *amp = (struct ackmsg *)nspp; + const struct ackmsg *amp = (const struct ackmsg *)nspp; int ack; - ack = EXTRACT_LE_16BITS(amp->ak_acknum[0]); + if (nsplen < sizeof(struct ackmsg)) + goto trunc; + ND_TCHECK(*amp); + ack = EXTRACT_LE_U_2(amp->ak_acknum[0]); if (ack & SGQ_ACK) { /* acknum field */ if ((ack & SGQ_NAK) == SGQ_NAK) - (void)printf("nak %d ", ack & SGQ_MASK); + ND_PRINT((ndo, "nak %d ", ack & SGQ_MASK)); else - (void)printf("ack %d ", ack & SGQ_MASK); - ack = EXTRACT_LE_16BITS(amp->ak_acknum[1]); + ND_PRINT((ndo, "ack %d ", ack & SGQ_MASK)); + ND_TCHECK(amp->ak_acknum[1]); + ack = EXTRACT_LE_U_2(amp->ak_acknum[1]); if (ack & SGQ_OACK) { /* ackdat field */ if ((ack & SGQ_ONAK) == SGQ_ONAK) - (void)printf("nakdat %d ", ack & SGQ_MASK); + ND_PRINT((ndo, "nakdat %d ", ack & SGQ_MASK)); else - (void)printf("ackdat %d ", ack & SGQ_MASK); + ND_PRINT((ndo, "ackdat %d ", ack & SGQ_MASK)); } } } break; case MFS_CACK: - (void)printf("conn-ack %d", dst); + ND_PRINT((ndo, "conn-ack %d", dst)); break; default: - (void)printf("reserved-acktype? %x %d > %d", flags, src, dst); + ND_PRINT((ndo, "reserved-acktype? %x %d > %d", flags, src, dst)); break; } break; @@ -556,155 +1072,140 @@ print_nsp(const u_char *nspp, u_int nsplen) case MFS_CI: case MFS_RCI: if ((flags & NSP_SUBMASK) == MFS_CI) - (void)printf("conn-initiate "); + ND_PRINT((ndo, "conn-initiate ")); else - (void)printf("retrans-conn-initiate "); - (void)printf("%d>%d ", src, dst); + ND_PRINT((ndo, "retrans-conn-initiate ")); + ND_PRINT((ndo, "%d>%d ", src, dst)); { - struct cimsg *cimp = (struct cimsg *)nspp; + const struct cimsg *cimp = (const struct cimsg *)nspp; int services, info, segsize; -#ifdef PRINT_NSPDATA - u_char *dp; -#endif - services = EXTRACT_LE_8BITS(cimp->ci_services); - info = EXTRACT_LE_8BITS(cimp->ci_info); - segsize = EXTRACT_LE_16BITS(cimp->ci_segsize); + if (nsplen < sizeof(struct cimsg)) + goto trunc; + ND_TCHECK(*cimp); + services = EXTRACT_U_1(cimp->ci_services); + info = EXTRACT_U_1(cimp->ci_info); + segsize = EXTRACT_LE_U_2(cimp->ci_segsize); switch (services & COS_MASK) { case COS_NONE: break; case COS_SEGMENT: - (void)printf("seg "); + ND_PRINT((ndo, "seg ")); break; case COS_MESSAGE: - (void)printf("msg "); - break; - case COS_CRYPTSER: - (void)printf("crypt "); + ND_PRINT((ndo, "msg ")); break; } switch (info & COI_MASK) { case COI_32: - (void)printf("ver 3.2 "); + ND_PRINT((ndo, "ver 3.2 ")); break; case COI_31: - (void)printf("ver 3.1 "); + ND_PRINT((ndo, "ver 3.1 ")); break; case COI_40: - (void)printf("ver 4.0 "); + ND_PRINT((ndo, "ver 4.0 ")); break; case COI_41: - (void)printf("ver 4.1 "); + ND_PRINT((ndo, "ver 4.1 ")); break; } - (void)printf("segsize %d ", segsize); -#ifdef PRINT_NSPDATA - dp = &(nspp[sizeof(struct cimsg)]); - pdata(dp, nsplen - sizeof(struct cimsg)); -#endif + ND_PRINT((ndo, "segsize %d ", segsize)); } break; case MFS_CC: - (void)printf("conn-confirm %d>%d ", src, dst); + ND_PRINT((ndo, "conn-confirm %d>%d ", src, dst)); { - struct ccmsg *ccmp = (struct ccmsg *)nspp; + const struct ccmsg *ccmp = (const struct ccmsg *)nspp; int services, info; u_int segsize, optlen; -#ifdef PRINT_NSPDATA - u_char *dp; -#endif - services = EXTRACT_LE_8BITS(ccmp->cc_services); - info = EXTRACT_LE_8BITS(ccmp->cc_info); - segsize = EXTRACT_LE_16BITS(ccmp->cc_segsize); - optlen = EXTRACT_LE_8BITS(ccmp->cc_optlen); + if (nsplen < sizeof(struct ccmsg)) + goto trunc; + ND_TCHECK(*ccmp); + services = EXTRACT_U_1(ccmp->cc_services); + info = EXTRACT_U_1(ccmp->cc_info); + segsize = EXTRACT_LE_U_2(ccmp->cc_segsize); + optlen = EXTRACT_U_1(ccmp->cc_optlen); switch (services & COS_MASK) { case COS_NONE: break; case COS_SEGMENT: - (void)printf("seg "); + ND_PRINT((ndo, "seg ")); break; case COS_MESSAGE: - (void)printf("msg "); - break; - case COS_CRYPTSER: - (void)printf("crypt "); + ND_PRINT((ndo, "msg ")); break; } switch (info & COI_MASK) { case COI_32: - (void)printf("ver 3.2 "); + ND_PRINT((ndo, "ver 3.2 ")); break; case COI_31: - (void)printf("ver 3.1 "); + ND_PRINT((ndo, "ver 3.1 ")); break; case COI_40: - (void)printf("ver 4.0 "); + ND_PRINT((ndo, "ver 4.0 ")); break; case COI_41: - (void)printf("ver 4.1 "); + ND_PRINT((ndo, "ver 4.1 ")); break; } - (void)printf("segsize %d ", segsize); + ND_PRINT((ndo, "segsize %d ", segsize)); if (optlen) { - (void)printf("optlen %d ", optlen); -#ifdef PRINT_NSPDATA - optlen = min(optlen, nsplen - sizeof(struct ccmsg)); - dp = &(nspp[sizeof(struct ccmsg)]); - pdata(dp, optlen); -#endif + ND_PRINT((ndo, "optlen %d ", optlen)); } } break; case MFS_DI: - (void)printf("disconn-initiate %d>%d ", src, dst); + ND_PRINT((ndo, "disconn-initiate %d>%d ", src, dst)); { - struct dimsg *dimp = (struct dimsg *)nspp; + const struct dimsg *dimp = (const struct dimsg *)nspp; int reason; u_int optlen; -#ifdef PRINT_NSPDATA - u_char *dp; -#endif - reason = EXTRACT_LE_16BITS(dimp->di_reason); - optlen = EXTRACT_LE_8BITS(dimp->di_optlen); + if (nsplen < sizeof(struct dimsg)) + goto trunc; + ND_TCHECK(*dimp); + reason = EXTRACT_LE_U_2(dimp->di_reason); + optlen = EXTRACT_U_1(dimp->di_optlen); - print_reason(reason); + print_reason(ndo, reason); if (optlen) { - (void)printf("optlen %d ", optlen); -#ifdef PRINT_NSPDATA - optlen = min(optlen, nsplen - sizeof(struct dimsg)); - dp = &(nspp[sizeof(struct dimsg)]); - pdata(dp, optlen); -#endif + ND_PRINT((ndo, "optlen %d ", optlen)); } } break; case MFS_DC: - (void)printf("disconn-confirm %d>%d ", src, dst); + ND_PRINT((ndo, "disconn-confirm %d>%d ", src, dst)); { - struct dcmsg *dcmp = (struct dcmsg *)nspp; + const struct dcmsg *dcmp = (const struct dcmsg *)nspp; int reason; - reason = EXTRACT_LE_16BITS(dcmp->dc_reason); + ND_TCHECK(*dcmp); + reason = EXTRACT_LE_U_2(dcmp->dc_reason); - print_reason(reason); + print_reason(ndo, reason); } break; default: - (void)printf("reserved-ctltype? %x %d > %d", flags, src, dst); + ND_PRINT((ndo, "reserved-ctltype? %x %d > %d", flags, src, dst)); break; } break; default: - (void)printf("reserved-type? %x %d > %d", flags, src, dst); + ND_PRINT((ndo, "reserved-type? %x %d > %d", flags, src, dst)); break; } + return (1); + +trunc: + return (0); } -static struct tok reason2str[] = { +static const struct tok reason2str[] = { { UC_OBJREJECT, "object rejected connect" }, { UC_RESOURCES, "insufficient resources" }, { UC_NOSUCHNODE, "unrecognized node name" }, @@ -731,13 +1232,14 @@ static struct tok reason2str[] = { }; static void -print_reason(register int reason) +print_reason(netdissect_options *ndo, + register int reason) { - printf("%s ", tok2str(reason2str, "reason-%d", reason)); + ND_PRINT((ndo, "%s ", tok2str(reason2str, "reason-%d", reason))); } -char * -dnnum_string(u_short dnaddr) +const char * +dnnum_string(netdissect_options *ndo, u_short dnaddr) { char *str; size_t siz; @@ -746,38 +1248,26 @@ dnnum_string(u_short dnaddr) str = (char *)malloc(siz = sizeof("00.0000")); if (str == NULL) - error("dnnum_string: malloc"); + (*ndo->ndo_error)(ndo, "dnnum_string: malloc"); snprintf(str, siz, "%d.%d", area, node); return(str); } -char * -dnname_string(u_short dnaddr) +const char * +dnname_string(netdissect_options *ndo, u_short dnaddr) { -#ifdef HAVE_LIBDNET +#ifdef HAVE_DNET_HTOA struct dn_naddr dna; + char *dnname; dna.a_len = sizeof(short); memcpy((char *)dna.a_addr, (char *)&dnaddr, sizeof(short)); - return (savestr(dnet_htoa(&dna))); + dnname = dnet_htoa(&dna); + if(dnname != NULL) + return (strdup(dnname)); + else + return(dnnum_string(ndo, dnaddr)); #else - return(dnnum_string(dnaddr)); /* punt */ + return(dnnum_string(ndo, dnaddr)); /* punt */ #endif } - -#ifdef PRINT_NSPDATA -static void -pdata(u_char *dp, u_int maxlen) -{ - char c; - u_int x = maxlen; - - while (x-- > 0) { - c = *dp++; - if (isprint(c)) - putchar(c); - else - printf("\\%o", c & 0xFF); - } -} -#endif